home *** CD-ROM | disk | FTP | other *** search
/ Chip 2002 November / Chip_2002-11_cd1.bin / zkuste / vbasic / Data / Utils / WME71SDK.exe / RCDATA / CABINET / common.h < prev    next >
C/C++ Source or Header  |  2001-03-02  |  13KB  |  499 lines
  1. #ifndef __UTILSVJIEF_H
  2. #define __UTILSVJIEF_H
  3.  
  4. #define EVENT_ID                        100
  5. #define WM_ENCODER_EVENT                WM_USER    + 2
  6. #define HR_TEST(hr)  if(FAILED(hr)) return hr; \
  7.  
  8. // menu id's
  9. #define ID_MENU_START    100
  10. #define ID_MENU_STOP    101
  11. #define ID_MENU_RESET    102
  12.  
  13.  
  14. class CEncoderView;
  15. typedef HRESULT (CEncoderView::*LPFNDISPLAY)(HTREEITEM hItem,IUnknown* pUnk);
  16.  
  17. CString _cdecl GetErrorFromHR(HRESULT hr);
  18. CString _cdecl GetError();
  19.  
  20. using namespace std;
  21. extern map<short,CString>    g_mapShortToString;
  22. extern map<WMENC_ENCODER_STATE,CString> g_mapRunState;
  23. extern map<WMENC_ARCHIVE_STATE,CString> g_archMap;
  24. extern map<WMENC_INDEXER_STATE,CString>    g_mapIndexerState;
  25. extern map<WMENC_ARCHIVE_OPERATION,CString> g_mapIndexerOp;
  26. extern map<WMENC_SOURCE_TYPE ,CString>        g_mapSourceType;
  27. extern map<WMENC_PLUGIN_TYPE ,CString>        g_mapPluginType;
  28. extern map<WMENC_ARCHIVE_OPERATION ,CString>        g_mapArchOp;
  29. extern map<long,CString>                    g_mapEventIDToDisplayString;
  30. extern map<WMENC_SOURCE_STATE ,CString>    g_mapSrcState;
  31. extern map<WMENC_BROADCAST_PROTOCOL ,CString>    g_mapBrProtocol;
  32.  
  33. struct ARCHIVESTATECHANGE
  34. {
  35.     WMENC_ARCHIVE_TYPE            m_archiveType;
  36.     WMENC_ARCHIVE_OPERATION        m_archiveOperation;
  37. };
  38.  
  39. struct CONFIGCHANGE
  40. {
  41.     long        m_lHr;
  42.     CComBSTR    m_bstr;
  43.     
  44.     CONFIGCHANGE()
  45.         :m_lHr(0)
  46.         ,m_bstr(_T(""))
  47.     {
  48.     }
  49. };
  50.  
  51. struct CLIENTCONNECT
  52. {
  53.     WMENC_BROADCAST_PROTOCOL    m_BrProtocol;
  54.     CComBSTR                    m_bstr;
  55.     // default values
  56.     CLIENTCONNECT()
  57.         :m_BrProtocol(WMENC_PROTOCOL_HTTP)
  58.         ,m_bstr(_T(""))
  59.     {
  60.     }
  61. };
  62.  
  63. struct CLIENTDISCONNECT
  64. {
  65.     WMENC_BROADCAST_PROTOCOL    m_BrProtocol;
  66.     CComBSTR                    m_bstr;
  67.  
  68.     CLIENTDISCONNECT()
  69.         :m_BrProtocol(WMENC_PROTOCOL_HTTP)
  70.         ,m_bstr(_T(""))
  71.     {
  72.     }
  73. };
  74.  
  75. struct SOURCESTATECHANGE
  76. {
  77.     WMENC_SOURCE_STATE            m_State;
  78.     WMENC_SOURCE_TYPE            m_SrcType;
  79.     short                        m_nIndex;
  80.     CComBSTR                    m_bstrSG;
  81.  
  82. // there are no default values for this as such, so using just the basic defaults
  83.     SOURCESTATECHANGE()
  84.         :m_State((WMENC_SOURCE_STATE)0)
  85.         ,m_SrcType((WMENC_SOURCE_TYPE)0)
  86.         ,m_nIndex(0)
  87.         ,m_bstrSG(_T(""))
  88.     {
  89.     }
  90. };
  91.  
  92. struct INDEXERSTATECHANGE
  93. {
  94.     WMENC_INDEXER_STATE            m_IndexerStateChange;
  95.     CComBSTR                    m_bstrFile;
  96.  
  97. // there are no default values for this as such, so using just the basic defaults
  98.     INDEXERSTATECHANGE()
  99.         :m_IndexerStateChange((WMENC_INDEXER_STATE)0)
  100.         ,m_bstrFile(_T(""))
  101.     {
  102.     }
  103. };
  104.  
  105.  
  106. // utility classes borrowed from MFC
  107. class CSyncObject 
  108. {
  109.     
  110. public:
  111.     CSyncObject(LPCTSTR pstrName);
  112.  
  113. // Attributes
  114. public:
  115.     operator HANDLE() const
  116.     {
  117.         return m_hObject;
  118.     }
  119.  
  120.     HANDLE  m_hObject;
  121.  
  122. // Operations
  123.     virtual BOOL Lock(DWORD dwTimeout = INFINITE);
  124.     virtual BOOL Unlock() = 0;
  125.     virtual BOOL Unlock(LONG /* lCount */, LPLONG /* lpPrevCount=NULL */)
  126.         { return TRUE; }
  127.  
  128. // Implementation
  129. public:
  130.     virtual ~CSyncObject();
  131. #ifdef _DEBUG
  132.     tstring m_strName;
  133.     
  134. #endif
  135.     friend class CSingleLock;
  136. };
  137.  
  138. class CEvent : public CSyncObject
  139. {
  140.  
  141. // Constructor
  142. public:
  143.     
  144. // Operations
  145. public:
  146.     CEvent(BOOL bInitiallyOwn = FALSE,
  147.         BOOL bManualReset = FALSE,
  148.         LPCTSTR lpszNAme = NULL, 
  149.         LPSECURITY_ATTRIBUTES lpsaAttribute = NULL)
  150.     : CSyncObject(lpszNAme)
  151.     {
  152.         m_hObject = ::CreateEvent(lpsaAttribute, bManualReset,
  153.             bInitiallyOwn, lpszNAme);
  154.     }
  155.  
  156.     virtual CEvent::~CEvent()
  157.     {
  158.     }
  159.  
  160.     BOOL SetEvent()
  161.     {
  162.         _ASSERT(m_hObject != NULL);
  163.         BOOL bRet = ::SetEvent(m_hObject); 
  164.         _ASSERT(bRet);
  165.         return bRet; 
  166.     }
  167.     BOOL PulseEvent()
  168.     {
  169.          _ASSERT(m_hObject != NULL); 
  170.          return ::PulseEvent(m_hObject);
  171.     }
  172.  
  173.     BOOL ResetEvent()
  174.     {
  175.         _ASSERT(m_hObject != NULL); 
  176.         return ::ResetEvent(m_hObject);
  177.     }
  178.     BOOL Unlock();
  179.  
  180. // Implementation
  181. public:
  182. };
  183.  
  184. class CSingleLock
  185. {
  186. // Constructors
  187. public:
  188.     CSingleLock(CSyncObject* pObject, BOOL bInitialLock = FALSE);
  189.  
  190. // Operations
  191. public:
  192.     BOOL Lock(DWORD dwTimeOut = INFINITE);
  193.     BOOL Unlock();
  194.     BOOL Unlock(LONG lCount, LPLONG lPrevCount = NULL);
  195.     BOOL IsLocked();
  196.  
  197. // Implementation
  198. public:
  199.     ~CSingleLock()
  200.     {
  201.         Unlock();
  202.     }
  203.  
  204. protected:
  205.     CSyncObject* m_pObject;
  206.     HANDLE  m_hObject;
  207.     BOOL    m_bAcquired;
  208. };
  209.  
  210.  
  211. // event sink object for encoder
  212. class CEncoderEventSink :
  213. public CComObjectRootEx<CComMultiThreadModel>,
  214. public IDispEventImpl<EVENT_ID,CEncoderEventSink,&DIID__IWMEncoderEvents,&LIBID_WMEncoderLib>
  215. {
  216. public:
  217.     static _ATL_FUNC_INFO StateChangeInfo;
  218.     static _ATL_FUNC_INFO ErrorInfo;
  219.     static _ATL_FUNC_INFO ArchiveStateChangeInfo;
  220.     static _ATL_FUNC_INFO ConfigChangeInfo;
  221.     static _ATL_FUNC_INFO ClientConnectInfo;
  222.     static _ATL_FUNC_INFO ClientDisconnectInfo;
  223.     static _ATL_FUNC_INFO SourceStateChangeInfo;
  224.     static _ATL_FUNC_INFO IndexerStateChangeInfo;
  225.  
  226. BEGIN_COM_MAP(CEncoderEventSink)
  227. END_COM_MAP()
  228.  
  229. public:
  230.     BEGIN_SINK_MAP(CEncoderEventSink)
  231.         SINK_ENTRY_INFO(EVENT_ID,DIID__IWMEncoderEvents,DISPID_ENCODEREVENT_STATECHANGE, OnStateChange,&StateChangeInfo)
  232.         SINK_ENTRY_INFO(EVENT_ID,DIID__IWMEncoderEvents,DISPID_ENCODEREVENT_ERROR, OnError,&ErrorInfo)
  233.         SINK_ENTRY_INFO(EVENT_ID,DIID__IWMEncoderEvents,DISPID_ENCODEREVENT_ARCHIVESTATECHANGE, OnArchiveStateChange,&ArchiveStateChangeInfo)
  234.         SINK_ENTRY_INFO(EVENT_ID,DIID__IWMEncoderEvents,DISPID_ENCODEREVENT_CONFIGCHANGE, OnConfigChange,&ConfigChangeInfo)
  235.         SINK_ENTRY_INFO(EVENT_ID,DIID__IWMEncoderEvents,DISPID_ENCODEREVENT_CLIENTCONNECT, OnClientConnect,&ClientConnectInfo)
  236.         SINK_ENTRY_INFO(EVENT_ID,DIID__IWMEncoderEvents,DISPID_ENCODEREVENT_CLIENTDISCONNECT, OnClientDisconnect,&ClientDisconnectInfo)
  237.         SINK_ENTRY_INFO(EVENT_ID,DIID__IWMEncoderEvents,DISPID_ENCODEREVENT_SRCSTATECHANGE, OnSourceStateChange,&SourceStateChangeInfo)
  238.         SINK_ENTRY_INFO(EVENT_ID,DIID__IWMEncoderEvents,DISPID_ENCODEREVENT_INDEXERSTATECHANGE, OnIndexerStateChange,&IndexerStateChangeInfo)
  239.     END_SINK_MAP()
  240.  
  241.  
  242. public:
  243.     STDMETHOD(OnStateChange)(/*[in]*/ WMENC_ENCODER_STATE enumState);
  244.     STDMETHOD(OnError)(/*[in]*/ long hResult);
  245.     STDMETHOD(OnArchiveStateChange)(/*[in]*/ WMENC_ARCHIVE_TYPE enumArchive, 
  246.                     /*[in] */ WMENC_ARCHIVE_OPERATION enumState);
  247.     STDMETHOD(OnConfigChange)(/*[in]*/ long hResult, 
  248.                     /*[in]*/ BSTR bstr);
  249.     STDMETHOD(OnClientConnect)(/*[in]*/ WMENC_BROADCAST_PROTOCOL protocol, 
  250.                 /*[in]*/ BSTR bstr);
  251.     STDMETHOD(OnClientDisconnect)(/*[in]*/ WMENC_BROADCAST_PROTOCOL protocol, 
  252.                 /*[in]*/ BSTR bstr);
  253.     STDMETHOD(OnSourceStateChange)(/*[in]*/ WMENC_SOURCE_STATE enumState, 
  254.                 /*[in]*/ WMENC_SOURCE_TYPE enumType, 
  255.                 /*[in]*/ short iIndex
  256.                 ,BSTR bstrSG);
  257.     STDMETHOD(OnIndexerStateChange)(/*[in]*/ WMENC_INDEXER_STATE enumIndexerState, 
  258.                 /*[in]*/ BSTR bstrFile);
  259.  
  260.     CEvent                m_eveStateChange;
  261.     CEvent                m_eveArchiveState;
  262.     CEvent                m_eveConfig;
  263.     CEvent                m_eveClientConnect;
  264.     CEvent                m_eveClientDisconnect;
  265.     CEvent                m_eveSourceState;
  266.     CEvent                m_eveIndexerState;
  267.     CEvent                m_eveError;
  268.  
  269.     CEvent                m_EventCalled; // this is the master event for which the object waits and when this is 
  270.     // signalled it checks for the other events
  271.     
  272.     WMENC_ENCODER_STATE    m_StateChange;
  273.     long                m_lError;
  274.     ARCHIVESTATECHANGE    m_archiveStateChange;
  275.     CONFIGCHANGE        m_ConfigChange;
  276.     CLIENTCONNECT        m_ClientConnect;
  277.     CLIENTDISCONNECT    m_ClientDisconnect;
  278.     SOURCESTATECHANGE    m_srcStateChange;
  279.     INDEXERSTATECHANGE    m_IndexerStateChange;
  280.  
  281.     // member to callback so that the client don't have to create a separate thread and wait for
  282.     // the event, needed for encview
  283.  
  284.     HWND    m_hMsgWnd;
  285.     DWORD    m_dwParam; //  to be passed back while sending the message
  286.     
  287.     CEncoderEventSink()
  288.         :m_hMsgWnd(NULL)
  289.         ,m_dwParam(0)
  290.     {
  291.  
  292.     }
  293.     ~CEncoderEventSink()
  294.     {
  295.  
  296.     }
  297.  
  298. };
  299.  
  300. inline STDMETHODIMP CEncoderEventSink::OnStateChange(WMENC_ENCODER_STATE enumState)
  301. {
  302.     using namespace std;
  303.     m_StateChange = enumState;
  304.     BOOL bRet = m_EventCalled.SetEvent();
  305.     _ASSERT(bRet);
  306.     bRet = m_eveStateChange.SetEvent();
  307.     _ASSERT(bRet);
  308.     if(m_hMsgWnd)
  309.     {
  310.         ::SendMessage(m_hMsgWnd,WM_ENCODER_EVENT,(WPARAM)m_dwParam,0);
  311.     }
  312.     map<WMENC_ENCODER_STATE,CString> runMap;
  313.     runMap[WMENC_ENCODER_STARTING] = _T("WMENC_ENCODER_STARTING");
  314.     runMap[WMENC_ENCODER_RUNNING ] = _T("WMENC_ENCODER_RUNNING ");
  315.     runMap[WMENC_ENCODER_PAUSED ] = _T("WMENC_ENCODER_PAUSED ");
  316.     runMap[WMENC_ENCODER_STOPPING ] = _T("WMENC_ENCODER_STOPPING ");
  317.     runMap[WMENC_ENCODER_STOPPED  ] = _T("WMENC_ENCODER_STOPPED ");
  318.     //::MessageBox(NULL,runMap[enumState],_T("Encoder state change"),MB_OK);
  319.     ATLTRACE("State change = %s\n",runMap[enumState]);
  320.     return S_OK;
  321. }
  322.  
  323. inline STDMETHODIMP CEncoderEventSink::OnError(long hResult)
  324. {
  325.     m_lError = hResult;
  326.     BOOL bRet = m_EventCalled.SetEvent();
  327.     _ASSERT(bRet);
  328.     bRet = m_eveError.SetEvent();
  329.     _ASSERT(bRet);
  330.     if(m_hMsgWnd)
  331.     {
  332.         ::SendMessage(m_hMsgWnd,WM_ENCODER_EVENT,(WPARAM)m_dwParam,0);
  333.     }
  334.     return S_OK;
  335. }
  336.  
  337. inline STDMETHODIMP CEncoderEventSink::OnArchiveStateChange(WMENC_ARCHIVE_TYPE enumArchive, 
  338.                                             WMENC_ARCHIVE_OPERATION enumState)
  339. {
  340.     m_archiveStateChange.m_archiveType = enumArchive;
  341.     m_archiveStateChange.m_archiveOperation = enumState;
  342.     BOOL bRet = m_EventCalled.SetEvent();
  343.     _ASSERT(bRet);
  344.     bRet = m_eveArchiveState.SetEvent();
  345.     _ASSERT(bRet);
  346.     if(m_hMsgWnd)
  347.     {
  348.         ::SendMessage(m_hMsgWnd,WM_ENCODER_EVENT,(WPARAM)m_dwParam,0);
  349.     }
  350.     return S_OK;
  351. }
  352.  
  353. inline STDMETHODIMP CEncoderEventSink::OnConfigChange(long hResult,BSTR bstr)
  354. {
  355.     m_ConfigChange.m_lHr = hResult;
  356.     m_ConfigChange.m_bstr = bstr;
  357.     BOOL bRet = m_EventCalled.SetEvent();
  358.     _ASSERT(bRet);
  359.     bRet = m_eveConfig.SetEvent();
  360.     _ASSERT(bRet);
  361.     if(m_hMsgWnd)
  362.     {
  363.         ::SendMessage(m_hMsgWnd,WM_ENCODER_EVENT,(WPARAM)m_dwParam,0);
  364.     }
  365.     return S_OK;
  366. }
  367.  
  368. inline STDMETHODIMP CEncoderEventSink::OnClientConnect(WMENC_BROADCAST_PROTOCOL protocol,BSTR bstr)
  369. {
  370.     m_ClientConnect.m_bstr = bstr;
  371.     m_ClientConnect.m_BrProtocol = protocol;
  372.     BOOL bRet = m_EventCalled.SetEvent();
  373.     _ASSERT(bRet);
  374.     bRet = m_eveClientConnect.SetEvent();
  375.     _ASSERT(bRet);
  376.     if(m_hMsgWnd)
  377.     {
  378.         ::SendMessage(m_hMsgWnd,WM_ENCODER_EVENT,(WPARAM)m_dwParam,0);
  379.     }
  380.     return S_OK;
  381. }
  382.  
  383. inline STDMETHODIMP CEncoderEventSink::OnClientDisconnect(WMENC_BROADCAST_PROTOCOL protocol, BSTR bstr)
  384. {
  385.     m_ClientDisconnect.m_BrProtocol = protocol;
  386.     m_ClientDisconnect.m_bstr = bstr;
  387.     BOOL bRet = m_EventCalled.SetEvent();
  388.     _ASSERT(bRet);
  389.     bRet = m_eveClientDisconnect.SetEvent();
  390.     _ASSERT(bRet);
  391.     if(m_hMsgWnd)
  392.     {
  393.         ::SendMessage(m_hMsgWnd,WM_ENCODER_EVENT,(WPARAM)m_dwParam,0);
  394.     }
  395.     return S_OK;
  396. }
  397.  
  398. inline STDMETHODIMP CEncoderEventSink::OnSourceStateChange(WMENC_SOURCE_STATE enumState, WMENC_SOURCE_TYPE enumType, 
  399.                 short iIndex, BSTR bstrSG)
  400. {
  401.     m_srcStateChange.m_nIndex = iIndex;
  402.     m_srcStateChange.m_SrcType = enumType;
  403.     m_srcStateChange.m_State = enumState;
  404.     m_srcStateChange.m_bstrSG = bstrSG;
  405.  
  406.     BOOL bRet = m_EventCalled.SetEvent();
  407.     _ASSERT(bRet);
  408.     bRet = m_eveSourceState.SetEvent();
  409.     _ASSERT(bRet);
  410.     if(m_hMsgWnd)
  411.     {
  412.         ::SendMessage(m_hMsgWnd,WM_ENCODER_EVENT,(WPARAM)m_dwParam,0);
  413.     }
  414.     return S_OK;
  415. }
  416.  
  417. inline STDMETHODIMP CEncoderEventSink::OnIndexerStateChange(WMENC_INDEXER_STATE enumIndexerState, BSTR bstrFile)
  418. {
  419.     m_IndexerStateChange.m_bstrFile = bstrFile;
  420.     m_IndexerStateChange.m_IndexerStateChange = enumIndexerState;
  421.  
  422.     BOOL bRet = m_EventCalled.SetEvent();
  423.     _ASSERT(bRet);
  424.     bRet = m_eveIndexerState.SetEvent();
  425.     _ASSERT(bRet);
  426.     if(m_hMsgWnd)
  427.     {
  428.         ::SendMessage(m_hMsgWnd,WM_ENCODER_EVENT,(WPARAM)m_dwParam,0);
  429.     }
  430.     return S_OK;
  431. }
  432.  
  433. struct TREEDATA
  434. {
  435.     LPFNDISPLAY pfnDisplay;
  436.     IUnknown*    pUnk;
  437.     TREEDATA()
  438.         :pUnk(NULL)
  439.         ,pfnDisplay(NULL)
  440.     {
  441.     }
  442.  
  443.     TREEDATA(IUnknown* pUnk1, LPFNDISPLAY pfn)
  444.         :pUnk(pUnk1)
  445.         ,pfnDisplay(pfn)
  446.     {
  447.         if(pUnk)
  448.             pUnk->AddRef();
  449.     }
  450.  
  451.     TREEDATA(const TREEDATA& data)
  452.     {
  453.         pUnk = data.pUnk;
  454.         if(pUnk)
  455.             pUnk->AddRef();
  456.         pfnDisplay = data.pfnDisplay;
  457.     }
  458.  
  459.     virtual ~TREEDATA()
  460.     {
  461.         if(pUnk)
  462.             pUnk->Release();
  463.     }
  464. };
  465.  
  466. // this extra member is needed to receive events in case we are an encoder node
  467. struct ENCDATA : public TREEDATA
  468. {
  469.     CEncoderEventSink*    pEvent;
  470.     ENCDATA()
  471.         :pEvent(NULL)
  472.     {
  473.     }
  474.     ENCDATA(IUnknown* pUnk1, LPFNDISPLAY pfn, CEncoderEventSink* pEve)
  475.         :TREEDATA(pUnk1, pfn), pEvent(pEve)
  476.     {
  477.     }
  478.  
  479.     ~ENCDATA()
  480.     {
  481.         CComQIPtr<IWMEncoder> pEnc(pUnk);
  482.         if(pEnc)
  483.         {
  484.             pEvent->DispEventUnadvise(pEnc);
  485.         }
  486.         if(pEvent)
  487.             delete pEvent;
  488.     }
  489.  
  490. };
  491.  
  492. typedef TREEDATA *LPTREEDATA;
  493.  
  494.  
  495. void InitMaps();
  496.  
  497.  
  498.  
  499. #endif //__UTILSVJIEF_H