CMedia更新至v1.4.3

//========================================================================
//TITLE:
//    CMedia更新至v1.4.3
//AUTHOR:
//    norains
//DATE:
//    Friday  27-July-2007
//Environment:
//        EVC4.0 + Windows CE 5.0 Standard SDK
//========================================================================

    相对v1.2.0版本进行的改进:

    1.增加GetMediaProperty函数获得的属性,增加如下属性:llDuration,llAvailableEarliest,llAvailableLatest.
   
    2.增加如下函数:SetRate(),GetRate(),GetPositionCurrent(),SetPositionCurrent() ,GetDisplayMode()
   
    3.改进之前一些函数的HRESULT值返回BOOL值的判定方法
   
    4.增加SetVideoWindow()一个参数,以设置可以在窗口的任意位置为起点播放视频
   
    5.改进SetDisplayMode()函数,当窗口句柄为空时,设置播放区域为0,并返回FALSE
   
    6.改进SetNotifyWindow()函数,令其能够接收普通的窗口消息
   
    7.Open()的参数改为const类型,更符合实际意义

    v1.2.0版本及相关用法见:http://blog.csdn.net/norains/archive/2007/05/14/1609118.aspx

 

    我们来看看具体更新了哪些功能:
   
    1.MEDIAPROPERTY
   
        增加了llDuration,llAvailableEarliest,llAvailableLatest属性,分别代表影片的时间长度,最早的可拖拽的时间位置,最早的可拖拽的时间位置.这个属性可以用在GetMediaProperty()函数中.
       
       
       
    2.SetRate(),GetRate()
   
        SetRate()设置当前的播放速率,"1"为正常速率,"2"即为两倍速,以此类推.
       
        GetRate()获取当前播放的速率.
       
       
       
    3.GetPositionCurrent(),SetPositionCurrent()
   
        GetPositionCurrent():获取当前的时间位置,返回的时间值以100ns为基本单位.   

        SetPositionCurrent():设置播放的时间位置,该范围必须是llAvailableEarliest和llAvailableLatest之间的数值.
       
       
       
    4.GetDisplayMode()
   
         该函数用来获取当前的播放模式.

   
   
    v1.4.3的完整代码如下:

///////////////////////////////////////////////////////////////////// //
// Media.h: interface for the CMedia class.
//
// Version:
//     1.4.3
// Date:
//     2007.07.19
///////////////////////////////////////////////////////////////////// /
#ifndef MEDIA_H
#define     MEDIA_H


#include  < mmsystem.h >
#include  < streams.h >

// --------------------------------------------------------------------
// Macro define

// The volume value
#define  MAX_VOLUME                    0
#define  MIN_VOLUME                    -10000

// The balance value
#define  MAX_BALANCE                    10000
#define  MIN_BALANCE                    -10000

// The flag means that the area is the whole window 
const  RECT RC_WHOLE_WINDOWN_AREA  =  { 0 , 0 , 0 , 0 };            

// --------------------------------------------------------------------
// Enum value

enum  DISPLAYMODE
{    
     // Fit to the play window size. How wide (height) the window is, how 
     // is the move. Keep aspect ratio.
    DISP_FIT,

     // Not support.Stretch to the play window size. Don't keep the aspect ratio.
    DISP_STRETCH,

     // Full screen play.
    DISP_FULLSCREEN,

     // When the size of video is smaller than the play window, it displayes
     // as the video size. If it's bigger , it just like the DISP_FIT mode.
    DISP_NATIVE
};
// --------------------------------------------------------------------

// The media file property
typedef  struct
{

     // The volume range is –10,000 to 0.
     // Divide by 100 to get equivalent decibel value (for example –10,000 = –100 dB). 
    LONG lVolume;


     // The value from –10,000 to 10,000 indicating the stereo balance
     // As with the Volume property, units correspond to .01 decibels (multiplied by –1 when plBalance is a positive value).
     // For example, a value of 1000 indicates –10 dB on the right channel and –90 dB on the left channel. 
    LONG lBalance;


     // Width of the video  
    LONG lWidth;


     // Height of the video
    LONG lHeight;


     // Approximate bit rate
    LONG lBitRate;

     // The length of time that the media stream will play.
     // The duration assumes normal playback speed, and it is therefore unaffected by the rate
    LONGLONG llDuration;


     // Earliest time that can be efficiently seeked to. 
    LONGLONG llAvailableEarliest;

     // Latest time that can be efficiently seeked to
    LONGLONG llAvailableLatest;

}MEDIAPROPERTY, * PMEDIAPROPERTY;
// --------------------------------------------------------------------
class  CMedia  
{
public :
    DISPLAYMODE GetDisplayMode();
    BOOL SetPositionCurrent(LONGLONG llPos);
    BOOL GetPositionCurrent(LONGLONG  * pllPos);
    BOOL GetRate( double   * pdRate);
    BOOL SetRate( double  dRate);
    BOOL GetEvent(LONG  * plEvCode, LONG  * plParam1, LONG  * plParam2);
    BOOL SetNotifyWindow(HWND hWnd, UINT wMsg, long  lInstanceData);
    BOOL SetVolume(LONG lVolume, LONG lBalance  =   0 );
    BOOL SetDisplayMode(DISPLAYMODE mode);
    BOOL GetMediaProperty(PMEDIAPROPERTY pOutProperty);
     static  CMedia  *  GetInstance();
     void  Close();
    BOOL CheckVisibility();
    BOOL SetVideoWindow(HWND hWndVideo, const  RECT  & rcDisp  =  RC_WHOLE_WINDOWN_AREA);
    BOOL Open( const  TCHAR  * pcszFileName);
    BOOL Stop();
    BOOL Pause();
    BOOL Play();
     virtual   ~ CMedia();

protected :


    CMedia();
    
     //  Collection of interfaces
    IGraphBuilder  * m_pGB;
    IMediaControl  * m_pMC;
    IMediaEventEx  * m_pME;
    IVideoWindow   * m_pVW;
    IBasicAudio    * m_pBA;
    IBasicVideo    * m_pBV;
    IMediaSeeking  * m_pMS;

    TCHAR m_szFileName[MAX_PATH];
    HWND m_hWndVideo;  // The window play video
    HWND m_hWndNotify;  // The window notify
    BOOL m_bExitThrd;
    BOOL m_bThrdRunning;
     static  CMedia  *  m_pInstance;
    DISPLAYMODE m_DispMode;
    DWORD m_dwCapability;
    RECT m_rcDisp;
};

#endif   // #ifndef MEDIA_H

 

///////////////////////////////////////////////////////////////////// //
//  Media.cpp: implementation of the CMedia class.
//
///////////////////////////////////////////////////////////////////// /

#include  " stdafx.h "
#include  " Media.h "



// ========================================================================================================
// Link the .lib
// The lib also is copy from "(InstallDir)WINCE500PUBLICDIRECTXSDKLIB"

#pragma  comment (lib,"Ole32.lib")

#ifdef CPU_X86EM
     #pragma  comment (lib,"./lib/X86em/Strmiids.lib")
     #pragma  comment (lib,"./lib/X86em/Strmbase.lib")
#endif

#ifdef CPU_MIPSII
     #pragma  comment (lib,"./lib/MIPSII/Strmiids.lib")
     #pragma  comment (lib,"./lib/MIPSII/Strmbase.lib")
#endif

#ifdef CPU_ARM4I
     #pragma  comment (lib,"./lib/ARM4I/Strmiids.lib")
     #pragma  comment (lib,"./lib/ARM4I/Strmbase.lib")
#endif
// ========================================================================================================

// ----------------------------------------------------------------------------------------------
// Macro define

// Default play mode
#define  DEFAULT_DISPLAY_MODE        DISP_NATIVE

// ----------------------------------------------------------------------
// Initialize
CMedia  * CMedia::m_pInstance  =  NULL;
// ------------------------------------------------------------------------


///////////////////////////////////////////////////////////////////// /
//  Construction/Destruction
///////////////////////////////////////////////////////////////////// /

CMedia::CMedia():
m_pGB(NULL),
m_pMC(NULL),
m_pME(NULL),
m_pVW(NULL),
m_pBA(NULL),
m_pBV(NULL),
m_pMS(NULL),
m_hWndVideo(NULL),
m_bExitThrd(TRUE),
m_bThrdRunning(FALSE),
m_DispMode(DEFAULT_DISPLAY_MODE),
m_hWndNotify(NULL),
m_rcDisp(RC_WHOLE_WINDOWN_AREA)
{
    memset(m_szFileName, 0 , sizeof (m_szFileName));
}

CMedia:: ~ CMedia()
{
     if (m_pInstance  !=  NULL)
    {
        delete m_pInstance;
        m_pInstance  =  NULL;
    }

}




// ------------------------------------------------------------
// Description:
//     Play the media file
//     When you call the function,you should call Open() before.
//
// -------------------------------------------------------------
BOOL CMedia::Play()
{    
     //  Run the graph to play the media file

     if (m_pMC  ==  NULL)
    {
         return  FALSE;
    }

        


     return  SUCCEEDED(m_pMC -> Run());

}




// ------------------------------------------------------------
// Description:
//     Pause. 
//     When you call the function,you should call Open() before.
//
// -------------------------------------------------------------
BOOL CMedia::Pause()
{

     if (m_pMC  ==  NULL)
    {
         return  FALSE;
    }
    
     return  SUCCEEDED(m_pMC -> Pause());

    
}




// ------------------------------------------------------------
// Description:
//     Stop.
//     When you call the function,you should call Open() before.
//
// -------------------------------------------------------------
BOOL CMedia::Stop()
{

     if (m_pMC  ==  NULL  ||  m_pMS  ==  NULL)
    {
         return  FALSE;
    }

    HRESULT hr;
    hr  =  m_pMC -> Stop();    
    SetPositionCurrent( 0 );    
   
     return  SUCCEEDED(hr);
}




// --------------------------------------------------------------------------
// Description:
//     Open the media file. When succeed in calling the function ,
// you should call the Close() to release the resource
//
// -------------------------------------------------------------------------
BOOL CMedia::Open( const  TCHAR  * pcszFileName)
{
    BOOL bResult  =  FALSE;
    

     if (_tcslen(pcszFileName)  >=  MAX_PATH)
    {
         goto  END;
    }
     else
    {
        _tcscpy(m_szFileName,pcszFileName);

         // Check the file existing
        HANDLE hdFile  =  CreateFile(m_szFileName,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,NULL,NULL);
         if (hdFile  ==  INVALID_HANDLE_VALUE)
        {
             // The file doesn't exist
             goto  END;
        }
         else
        {
            CloseHandle(hdFile);
        }
    }

    



     //  Initialize COM 
     if (CoInitializeEx(NULL, COINIT_MULTITHREADED)  !=  S_OK)
    {
         goto  END;
    }

     //  Get the interface for DirectShow's GraphBuilder
     if (CoCreateInstance(CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER, IID_IGraphBuilder, ( void   ** ) & m_pGB)  !=  S_OK)
    {
         goto  END;
    }


     //  Have the graph construct its the appropriate graph automatically
     if (m_pGB -> RenderFile(m_szFileName, NULL)  !=  NOERROR)
    {
         goto  END;
    }
    

     //  QueryInterface for DirectShow interfaces
     if (m_pGB -> QueryInterface(IID_IMediaControl, ( void   ** ) & m_pMC)  !=  NOERROR)
    {
         goto  END;
    }
     if (m_pGB -> QueryInterface(IID_IMediaEventEx, ( void   ** ) & m_pME)  !=  NOERROR)
    {
         goto  END;
    }
     if (m_pGB -> QueryInterface(IID_IMediaSeeking, ( void   ** ) & m_pMS)  !=  NOERROR)
    {
         goto  END;
    }
    
    
    
     //  Query for video interfaces, which may not be relevant for audio files
     if (m_pGB -> QueryInterface(IID_IVideoWindow, ( void   ** ) & m_pVW)  !=  NOERROR)
    {
         goto  END;
    }
     if (m_pGB -> QueryInterface(IID_IBasicVideo, ( void   ** ) & m_pBV)  !=  NOERROR)
    {
         goto  END;
    }
    
     if (CheckVisibility()  ==  FALSE)
    {
         // It just be the audio file, and don't need video filter.

         //  Relinquish ownership (IMPORTANT!) after hiding
         if (m_pVW  !=  NULL)
        {
            m_pVW -> put_Visible(OAFALSE);
            m_pVW -> put_Owner(NULL);
        }

         if (m_pBV  !=  NULL)
        {
            m_pBV -> Release();
            m_pBV  =  NULL;
        }    

    
         if (m_pVW  !=  NULL)
        {
            m_pVW -> Release();
            m_pVW  =  NULL;
        }
    }
    

     //  Query for audio interfaces, which may not be relevant for video-only files
     if (m_pGB -> QueryInterface(IID_IBasicAudio, ( void   ** ) & m_pBA)  !=  NOERROR)
    {
         goto  END;
    }


     // Set play mode
    SetDisplayMode(m_DispMode);
    
     // Get the capabilities of the media file.
    m_pMS -> GetCapabilities( & m_dwCapability);
    
    bResult  =  TRUE;

END:    

     if (bResult  ==  FALSE)
    {
         // Release the resource
        Close();
    }

     return  bResult;
}




// ------------------------------------------------------------
// Description:
//     This method sets an owning parent for the video window. 
//
// Parameters:
//     hWnd : [in] Handle of new owner window. 
//     rcDisp: [in] The display area. If the parameter is not set,
//             it will be set as RC_WHOLE_WINDOWN_AREA which means thai
//             the whole window is for displaying the video.
//
// ----------------------------------------------------------
BOOL CMedia::SetVideoWindow(HWND hWndVideo, const  RECT  & rcDisp)
{
    m_hWndVideo  =  hWndVideo;
    
    m_rcDisp  =  rcDisp;

     if (m_pVW  ==  NULL)
    {
         return  FALSE;
    }

     if (FAILED(m_pVW -> put_Owner((OAHWND)hWndVideo)))
    {
         return  FALSE;
    }

     if (FAILED(m_pVW -> put_WindowStyle(WS_CHILD  |  WS_CLIPSIBLINGS  |  WS_CLIPCHILDREN)))
    {
         return  FALSE;
    }

     // Set play mode in order to notify the displayed area
     return  SetDisplayMode(m_DispMode);
}



// ------------------------------------------------------------
// Description:
//     Check the file visibility
//     When you call the function,you should call Open() before.
//
// Parameters:
//     TRUE: Video
//     FALSE: It's not the video 
//
// ------------------------------------------------------------
BOOL CMedia::CheckVisibility()
{
    
    
     if  ( ! m_pVW)
    {
         // No VideoWindow interface.  Assuming audio/MIDI file or unsupported video codec
         return  FALSE;
    }
    
     if  ( ! m_pBV)
    {
         // No BasicVideo interface.  Assuming audio/MIDI file or unsupported video codec.
         return  FALSE;
    }
    
    
     //  If this is an audio-only clip, get_Visible() won't work.
     //
     //  Also, if this video is encoded with an unsupported codec,
     //  we won't see any video, although the audio will work if it is
     //  of a supported format.
     long  lVisible;
     return  SUCCEEDED(m_pVW -> get_Visible( & lVisible));
    
}




// ------------------------------------------------------------
// Description:
//     Release the resource which opened in the Open()    
//
// ------------------------------------------------------------
void  CMedia::Close()
{

     //  Relinquish ownership (IMPORTANT!) after hiding
     if (m_pVW  !=  NULL)
    {
        m_pVW -> put_Visible(OAFALSE);
        m_pVW -> put_Owner(NULL);
    }

     if (m_pMC  !=  NULL)
    {
        m_pMC -> Release();
        m_pMC  =  NULL;
    }

     if (m_pME  !=  NULL)
    {
        m_pME -> SetNotifyWindow(NULL,NULL,NULL);

        m_pME -> Release();
        m_pME  =  NULL;
    }

     if (m_pMS  !=  NULL)
    {
        m_pMS -> Release();
        m_pMS  =  NULL;
    }

     if (m_pBV  !=  NULL)
    {
        m_pBV -> Release();
        m_pBV  =  NULL;
    }
    
     if (m_pBA  !=  NULL)
    {
        m_pBA -> Release();
        m_pBA  =  NULL;
    }
    
     if (m_pVW  !=  NULL)
    {
        m_pVW -> Release();
        m_pVW  =  NULL;
    }

     if (m_pGB  !=  NULL)
    {
        m_pGB -> Release();
        m_pGB  =  NULL;
    }

     //  Finished with COM
    memset(m_szFileName, 0 , sizeof (m_szFileName));


    CoUninitialize();
}


// ------------------------------------------------------------
// Description:
//     Get the instance of object
//
// ------------------------------------------------------------
CMedia  *  CMedia::GetInstance()
{
     if (m_pInstance  ==  NULL)
    {
        m_pInstance  =   new  CMedia();
    }

     return  m_pInstance;
}




// ------------------------------------------------------------
// Description:
//     Get the media file property.
//     When you call the function,you should call Open() before.
//
// ------------------------------------------------------------
BOOL CMedia::GetMediaProperty(PMEDIAPROPERTY pOutProperty)
{

    MEDIAPROPERTY prop  =  { 0 };

     if (m_pBA  ==  NULL  &&  m_pBV  ==  NULL  &&  m_pMS  ==  NULL)
    {
         return  FALSE;
    }


     // Get the audio property
     if (m_pBA  !=  NULL)
    {
        m_pBA -> get_Volume( & prop.lVolume);
        m_pBA -> get_Balance( & prop.lBalance);
    }


     // Get the video property
     if (CheckVisibility()  ==  TRUE  &&  m_pBV  !=  NULL)
    {        
        m_pBV -> get_BitRate( & prop.lBitRate);
        m_pBV -> GetVideoSize( & prop.lWidth, & prop.lHeight);        
    }


     // Get the seeking property
     if (m_pMS  !=  NULL)
    {
        m_pMS -> GetDuration( & prop.llDuration);
        m_pMS -> GetAvailable( & prop.llAvailableEarliest, & prop.llAvailableLatest);
    }



     * pOutProperty  =  prop;


     return  TRUE;
}


// ------------------------------------------------------------
// Description:
//     Set the display mode.
//     When you call the function,you should call SetVideoWindow() before.
// If the parent windows (m_hWndVideo) is NULL, the display area would be set to zero.
//
// ------------------------------------------------------------
BOOL CMedia::SetDisplayMode(DISPLAYMODE mode)
{

     if (m_pVW  ==  NULL)
    {
         return  FALSE;
    }

     if (m_hWndVideo  ==  NULL)
    {
        m_pVW -> put_Left( 0 );
        m_pVW -> put_Top( 0 );
        m_pVW -> put_Width( 0 );
        m_pVW -> put_Height( 0 );

         return  FALSE;
    }

    m_DispMode  =  mode;

     if (mode  ==  DISP_FULLSCREEN)
    {
        m_pVW -> put_FullScreenMode(OATRUE);
    }
     else
    {
         // Restore to the normal mode
        m_pVW -> put_FullScreenMode(OAFALSE);
        
        RECT rcWnd  =  m_rcDisp;
         if (rcWnd.left  ==  RC_WHOLE_WINDOWN_AREA.left  &&
            rcWnd.top  ==  RC_WHOLE_WINDOWN_AREA.top  &&
            rcWnd.right  ==  RC_WHOLE_WINDOWN_AREA.right  &&
            rcWnd.bottom  ==  RC_WHOLE_WINDOWN_AREA.bottom )
        {
            GetClientRect(m_hWndVideo, & rcWnd);
        }
        LONG lWndWidth  =  rcWnd.right  -  rcWnd.left;
        LONG lWndHeight  =  rcWnd.bottom  -  rcWnd.top;

        MEDIAPROPERTY prop  =  { 0 };
        GetMediaProperty( & prop);


         if (mode  ==  DISP_FIT  ||  mode  ==  DISP_NATIVE)
        {
            LONG lDispLeft,lDispTop,lDispWidth,lDispHeight;

             if (mode  ==  DISP_NATIVE  &&  lWndWidth  >=  prop.lWidth  &&  lWndHeight  >=  prop.lHeight)
            {
                lDispLeft  =  (lWndWidth  -  prop.lWidth)  /   2   +  rcWnd.left;
                lDispTop  =  (lWndHeight  -  prop.lHeight)  /   2   +  rcWnd.top;
                lDispWidth  =  prop.lWidth ;
                lDispHeight  =  prop.lHeight ;
            }
             else
            {
                 if (prop.lWidth  *  lWndHeight  >  lWndWidth  *  prop.lHeight)
                {
                    lDispWidth  =  lWndWidth;                
                    lDispHeight  =  (LONG)(( float )lDispWidth  /  ( float )prop.lWidth  *  prop.lHeight);
                    lDispLeft  =  rcWnd.left;
                    lDispTop  =  (lWndHeight  -  lDispHeight)  /   2   +  rcWnd.top;        
                }
                 else   if (prop.lWidth  *  lWndHeight  <  lWndWidth  *  prop.lHeight)
                {
                    lDispHeight  =  lWndHeight;
                    lDispWidth  =  (LONG)(( float )lDispHeight  /  ( float )prop.lHeight  *  prop.lWidth);
                    lDispLeft  =  (lWndWidth  -  lDispWidth)  /   2   +  rcWnd.left;
                    lDispTop  =  rcWnd.top;
                }
                 else
                {
                    lDispWidth  =  lWndWidth;                
                    lDispHeight  =  lWndHeight;
                    lDispLeft  =  rcWnd.left;
                    lDispTop  =  rcWnd.top;
                }
            }

            



            m_pVW -> put_Left(lDispLeft);
            m_pVW -> put_Top(lDispTop);
            m_pVW -> put_Width(lDispWidth);
            m_pVW -> put_Height(lDispHeight);
        }
         else   if (mode  ==  DISP_STRETCH)
        {

            m_pVW -> put_Left(rcWnd.left);
            m_pVW -> put_Top(rcWnd.top);
            m_pVW -> put_Width(lWndWidth);
            m_pVW -> put_Height(lWndHeight);
        }
    
    }



     return  TRUE;
}


// ------------------------------------------------------------
// Description:
//     Set the volume.
//     When you call the function,you should call Open() before.
//
// Parameters:
//     lVolume:[in] The volume (amplitude) of the audio signal. 
//             Range is –10,000 to 0.
//     lBalance:[in]  The balance for the audio signal. Default value is 0.
//             The value from –10,000 to 10,000 indicating the stereo balance.
//
// ------------------------------------------------------------
BOOL CMedia::SetVolume(LONG lVolume, LONG lBalance)
{
     if (m_pBA  ==  NULL)
    {
         return  FALSE;
    }

     if (lVolume  <  MIN_VOLUME  &&  lVolume  >  MAX_VOLUME  &&  lBalance  <  MIN_BALANCE  &&  lBalance  >  MAX_BALANCE)
    {
         return  FALSE;
    }

    m_pBA -> put_Volume(lVolume);
    m_pBA -> put_Balance(lBalance);

     return  TRUE;
}




// ----------------------------------------------------------------------
// Description:
//     Registers a window that will handle the notified message when a specified event occurs and some window message
//
// Parameters:
//     hWnd:[in] Handle of window to notify. Pass NULL to stop notification. 
//     wMsg:[in] Window message to be passed as the notification. 
//     lInstanceData:[in] Value (instance data) to be passed as the lParam parameter for the lMsg message.
//
// Remarks:
//     When the notified window receive the wMsg as the notification, you could get the event code.
//     The follow codes show that process:
//
//          // "WM_GRAPHNOTIFY" is the user-define notified message
//         case WM_GRAPHNOTIFY:
//         {
//             LONG evCode,evParam1,evParam2;
//
//              // "m_pMedia" is the instance of the CMedia
//             if(m_pMedia->GetEvent(&evCode,&evParam1,&evParam2) == TRUE)
//             {                
//                  // Check the event code
//                 if(evCode == EC_COMPLETE)
//                 {
//                      // Do something
//                 }
//             }
//             return 0;
//         } 
//
//     The event code is as follow:
//  EC_ACTIVATE                     An audio or video renderer is losing or gaining activation.  
//  EC_BUFFERING_DATA               The buffering status is changing.  
//  EC_CLOCK_CHANGED                The filter graph has changed from one reference clock to another.  
//  EC_COMPLETE                     All data has been rendered.  
//  EC_DRM_LEVEL                    Notifies when content protected by digital rights management (DRM) requests some form of analog content protection. 
//  EC_END_OF_SEGMENT               Notifies that a segment end has been reached.  
//  EC_ERROR_STILLPLAYING           At least one call to Run failed in an active filter graph. 
//                                     The current state of any underlying filter graph or graphs is indeterminate; they might be running, but some are almost certainly not. 
//  EC_ERRORABORT                   An error forced the termination of a requested operation.  
//  EC_FULLSCREEN_LOST              The video renderer is switching out of full-screen mode.  
//  EC_NEED_RESTART                 The current graph must be stopped and restarted.  
//  EC_NOTIFY_WINDOW                Pass the window handle around during pin connection.  
//  EC_OLE_EVENT                    A filter is passing a text string to the application.  
//  EC_OPENING_FILE                 The open file status is changing.  
//  EC_PALETTE_CHANGED              The video palette has changed.  
//  EC_QUALITY_CHANGE               The playback quality has changed.  
//  EC_REPAINT                      A repaint is required.  
//  EC_SEGMENT_STARTED              Notifies that a new segment has been started.  
//  EC_SHUTTING_DOWN                The filter graph is starting to shut down. 
//                                     DirectShow passes this notification to any plug-in distributors that support the IMediaEventSink interface. 
//  EC_STARVATION                   One of the filters (usually a parser or file source filter) is not receiving enough data. 
//                                     By default, the filter graph manager will pause all running filters and then return to normal operation when enough data is available. 
//  EC_STREAM_CONTROL_STARTED       The starting reference time from an earlier call to IAMStreamControl::StartAt passed.  
//  EC_STREAM_CONTROL_STOPPED       The stopping reference time from an earlier call to IAMStreamControl::StopAt passed.  
//  EC_STREAM_ERROR_STILLPLAYING    The stream is still playing, but should not be playing.  
//  EC_STREAM_ERROR_STOPPED         The stream has stopped, but should not have stopped.  
//  EC_TIME                         The requested reference time occurred.  
//  EC_USERABORT                    A user has forced the termination of a requested operation.  
//  EC_VIDEO_SIZE_AR_CHANGED        The size or aspect ratio of the native video has changed.  
//  EC_VIDEO_SIZE_CHANGED           The size of the native video has changed.  
//  EC_WINDOW_DESTROYED             The video renderer's filter is being removed or destroyed.  
//
//
//
//     DirectShow passes the following messages to the window specified by the hWnd parameter, 
// if and when the application generates them: 
//  WM_KEYDOWN 
//  WM_KEYUP 
//  WM_LBUTTONDBLCLK 
//  WM_LBUTTONDOWN 
//  WM_LBUTTONUP 
//  WM_MBUTTONDBLCLK 
//  WM_MBUTTONDOWN 
//  WM_MBUTTONUP 
//  WM_MOUSEACTIVATE 
//  WM_MOUSEMOVE 
//  WM_RBUTTONDBLCLK 
//  WM_RBUTTONDOWN 
//  WM_RBUTTONUP 
// -----------------------------------------------------------------------------
BOOL CMedia::SetNotifyWindow(HWND hWnd, UINT wMsg, long  lInstanceData)
{


     if (m_pME  ==  NULL)
    {
         return  FALSE;
    }

    HRESULT hr;
    hr  =  m_pME -> SetNotifyWindow((OAHWND)hWnd,wMsg,lInstanceData);
     if (FAILED(hr))
    {
         return  FALSE;
    }

     if (CheckVisibility()  ==  TRUE  &&  m_pVW  !=  NULL)
    {
        hr  =  m_pVW -> put_MessageDrain((OAHWND)hWnd);
    }
    

    
    
     return  SUCCEEDED(hr);
}


// ----------------------------------------------------------------------
// Description:
//     This method retrieves the notification event. 
//
// -----------------------------------------------------------------------
BOOL CMedia::GetEvent(LONG  * plEvCode, LONG  * plParam1, LONG  * plParam2)
{
     if (m_pME  ==  NULL)
    {
         return  FALSE;
    }

    LONG evCode, evParam1, evParam2;    

     if (SUCCEEDED(m_pME -> GetEvent( & evCode,  & evParam1,  & evParam2,  0 ))  ==  TRUE)
    {
         * plEvCode  =  evCode;
         * plParam1  =  evParam1;
         * plParam2  =  evParam2;

         //  Spin through the events
        m_pME -> FreeEventParams(evCode, evParam1, evParam2);        
    }
     else
    {
         return  FALSE;
    }
    

     return  TRUE;
}


// ----------------------------------------------------------------------
// Description:
//     This method sets a new playback rate. 
//
// Parameters
//     dRate:[in] New rate, where 1 is the normal rate, 2 is twice as fast, and so on. 

// -----------------------------------------------------------------------
BOOL CMedia::SetRate( double  dRate)
{
     if (m_pMS  ==  NULL)
    {
         return  FALSE;
    }
     return  SUCCEEDED(m_pMS -> SetRate(dRate));
}


// ----------------------------------------------------------------------
// Description:
//     This method retrieves the current rate.
//
// Parameters:
//     pdRate:[out] The rate
// -----------------------------------------------------------------------
BOOL CMedia::GetRate( double   * pdRate)
{
     if (m_pMS  ==  NULL)
    {
         return  FALSE;
    }

     return  SUCCEEDED(m_pMS -> GetRate(pdRate));

}

// ----------------------------------------------------------------------
// Description:
//     This method retrieves the current position in terms of the total length of the media stream
//
// Parameters:
//     pllPos:[out]Current position.
// -----------------------------------------------------------------------
BOOL CMedia::GetPositionCurrent(LONGLONG  * pllPos)
{
     if (m_pMS  ==  NULL)
    {
         return  FALSE;
    }

     if (m_dwCapability  &  AM_SEEKING_CanGetCurrentPos  ==   0 )
    {
         return  FALSE;
    }

     return  SUCCEEDED(m_pMS -> GetCurrentPosition(pllPos));
}

// ----------------------------------------------------------------------
// Description:
//     This method sets current positions
//
// Parameters:
//     llPos:[in]Start position if stopped, or position from which to continue if paused. 
// -----------------------------------------------------------------------
BOOL CMedia::SetPositionCurrent(LONGLONG llPos)
{
     if (m_pMS  ==  NULL)
    {
         return  FALSE;
    }

    LONGLONG llCur  =   0 ;
     if (GetPositionCurrent( & llCur)  ==  TRUE)
    {
         if ((llCur  >  llPos)  &&  (m_dwCapability  &  AM_SEEKING_CanSeekBackwards  ==   0 ))
        {
             return  FALSE;
        }
         else   if ((llCur  <  llPos)  &&  (m_dwCapability  &  AM_SEEKING_CanSeekForwards  ==   0 ))
        {            
             return  FALSE;            
        }
         else   if (llCur  ==  llPos)
        {
             // It's the current positon, needn't set
             return  TRUE;
        }
    }
     else   if ((m_dwCapability  &  AM_SEEKING_CanSeekBackwards  ==   0 )  ||  (m_dwCapability  &  AM_SEEKING_CanSeekForwards  ==   0 ))
    {
         return  FALSE;
    }


     return  SUCCEEDED(m_pMS -> SetPositions( & llPos,AM_SEEKING_AbsolutePositioning,NULL,AM_SEEKING_NoPositioning));
}


// ----------------------------------------------------------------------
// Description:
//     This method get current display mode
//
// ----------------------------------------------------------------------
DISPLAYMODE CMedia::GetDisplayMode()
{
     return  m_DispMode;
}