开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
CDXGraph.cpp
资源名称：Visual C++视频音频开发实用工程案例精选.rar　[点击查看]
上传用户：tuheem
上传日期：2007-05-01
资源大小：21889k
文件大小：10k
源码类别：

多媒体编程

开发平台：

Visual C++

CDXGraph.cpp：源码内容
  1. //
  2. // CDXGraph.cpp
  3. //
  5. #include "stdafx.h"
  6. #include <streams.h>
  7. #include "CDXGraph.h"
  9. #ifdef _DEBUG
  10. #define new DEBUG_NEW
  11. #undef THIS_FILE
  12. static char THIS_FILE[] = __FILE__;
  13. #endif
  15. ////////////////////////////////////////////////////////////////////////////////
  16. CDXGraph::CDXGraph()
  17. {
  18. mGraph        = NULL;
  19. mMediaControl = NULL;
  20. mEvent        = NULL;
  21. mBasicVideo   = NULL;
  22. mBasicAudio   = NULL;
  23. mVideoWindow  = NULL;
  24. mSeeking      = NULL;
  26. mObjectTableEntry = 0;
  27. }
  29. CDXGraph::~CDXGraph()
  30. {
  31. Release();
  32. }
  34. bool CDXGraph::Create(void)
  35. {
  36. if (!mGraph)
  37. {
  38. if (SUCCEEDED(CoCreateInstance(CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER,
  39. IID_IGraphBuilder, (void **)&mGraph)))
  40. {
  41. AddToObjectTable();
  43. return QueryInterfaces();
  44. }
  45. mGraph = 0;
  46. }
  47. return false;
  48. }
  50. bool CDXGraph::QueryInterfaces(void)
  51. {
  52. if (mGraph)
  53. {
  54. HRESULT hr = NOERROR;
  55. hr |= mGraph->QueryInterface(IID_IMediaControl, (void **)&mMediaControl);
  56. hr |= mGraph->QueryInterface(IID_IMediaEventEx, (void **)&mEvent);
  57. hr |= mGraph->QueryInterface(IID_IBasicVideo, (void **)&mBasicVideo);
  58. hr |= mGraph->QueryInterface(IID_IBasicAudio, (void **)&mBasicAudio);
  59. hr |= mGraph->QueryInterface(IID_IVideoWindow, (void **)&mVideoWindow);
  60. hr |= mGraph->QueryInterface(IID_IMediaSeeking, (void **)&mSeeking);
  61. if (mSeeking)
  62. {
  63. mSeeking->SetTimeFormat(&TIME_FORMAT_MEDIA_TIME);
  64. }
  65. return SUCCEEDED(hr);
  66. }
  67. return false;
  68. }
  70. HRESULT CDXGraph::QueryInterface(REFIID inIID, void ** ppvObject)
  71. {
  72. HRESULT hr = E_FAIL;
  73. if (mGraph)
  74. {
  75. hr = mGraph->QueryInterface(inIID, ppvObject);
  76. }
  77. return hr;
  78. }
  80. void CDXGraph::Release(void)
  81. {
  82. if (mSeeking)
  83. {
  84. mSeeking->Release();
  85. mSeeking = NULL;
  86. }
  87. if (mMediaControl)
  88. {
  89. mMediaControl->Release();
  90. mMediaControl = NULL;
  91. }
  92. if (mEvent)
  93. {
  94. mEvent->Release();
  95. mEvent = NULL;
  96. }
  97. if (mBasicVideo)
  98. {
  99. mBasicVideo->Release();
  100. mBasicVideo = NULL;
  101. }
  102. if (mBasicAudio)
  103. {
  104. mBasicAudio->Release();
  105. mBasicAudio = NULL;
  106. }
  107. if (mVideoWindow)
  108. {
  109. mVideoWindow->put_Visible(OAFALSE);
  110. mVideoWindow->put_MessageDrain((OAHWND)NULL);
  111. mVideoWindow->put_Owner(OAHWND(0));
  112. mVideoWindow->Release();
  113. mVideoWindow = NULL;
  114. }
  115. RemoveFromObjectTable();
  116. if (mGraph) 
  117. {
  118. mGraph->Release(); 
  119. mGraph = NULL;
  120. }
  121. }
  123. bool CDXGraph::Attach(IGraphBuilder * inGraphBuilder)
  124. {
  125. Release();
  127. if (inGraphBuilder)
  128. {
  129. inGraphBuilder->AddRef();
  130. mGraph = inGraphBuilder;
  132. AddToObjectTable();
  133. return QueryInterfaces();
  134. }
  135. return true;
  136. }
  138. IGraphBuilder * CDXGraph::GetGraph(void)
  139. {
  140. return mGraph;
  141. }
  143. IMediaEventEx * CDXGraph::GetEventHandle(void)
  144. {
  145. return mEvent;
  146. }
  148. // Connect filter from the upstream output pin to the downstream input pin
  149. bool CDXGraph::ConnectFilters(IPin * inOutputPin, IPin * inInputPin, 
  150.   const AM_MEDIA_TYPE * inMediaType)
  151. {
  152. if (mGraph && inOutputPin && inInputPin)
  153. {
  154. HRESULT hr = mGraph->ConnectDirect(inOutputPin, inInputPin, inMediaType);
  155. return SUCCEEDED(hr) ? true : false;
  156. }
  157. return false;
  158. }
  160. void CDXGraph::DisconnectFilters(IPin * inOutputPin)
  161. {
  162. if (mGraph && inOutputPin)
  163. {
  164. HRESULT hr = mGraph->Disconnect(inOutputPin);
  165. }
  166. }
  168. bool CDXGraph::SetDisplayWindow(HWND inWindow)
  169. {
  170. if (mVideoWindow)
  171. {
  172. // long lVisible;
  173. // mVideoWindow->get_Visible(&lVisible);
  174. // Hide the video window first
  175. mVideoWindow->put_Visible(OAFALSE);
  176. mVideoWindow->put_Owner((OAHWND)inWindow);
  178. RECT windowRect;
  179. ::GetClientRect(inWindow, &windowRect);
  180. mVideoWindow->put_Left(0);
  181. mVideoWindow->put_Top(0);
  182. mVideoWindow->put_Width(windowRect.right - windowRect.left);
  183. mVideoWindow->put_Height(windowRect.bottom - windowRect.top);
  184. mVideoWindow->put_WindowStyle(WS_CHILD|WS_CLIPCHILDREN|WS_CLIPSIBLINGS);
  186. mVideoWindow->put_MessageDrain((OAHWND) inWindow);
  187. // Restore the video window
  188. if (inWindow != NULL)
  189. {
  190. // mVideoWindow->put_Visible(lVisible);
  191. mVideoWindow->put_Visible(OATRUE);
  192. }
  193. else
  194. {
  195. mVideoWindow->put_Visible(OAFALSE);
  196. }
  197. return true;
  198. }
  199. return false;
  200. }
  202. bool CDXGraph::ResizeVideoWindow(long inLeft, long inTop, long inWidth, long inHeight)
  203. {
  204. if (mVideoWindow)
  205. {
  206. long lVisible = OATRUE;
  207. mVideoWindow->get_Visible(&lVisible);
  208. // Hide the video window first
  209. mVideoWindow->put_Visible(OAFALSE);
  211. mVideoWindow->put_Left(inLeft);
  212. mVideoWindow->put_Top(inTop);
  213. mVideoWindow->put_Width(inWidth);
  214. mVideoWindow->put_Height(inHeight);
  216. // Restore the video window
  217. mVideoWindow->put_Visible(lVisible);
  218. return true;
  219. }
  220. return false;
  221. }
  223. bool CDXGraph::SetNotifyWindow(HWND inWindow)
  224. {
  225. if (mEvent)
  226. {
  227. mEvent->SetNotifyWindow((OAHWND)inWindow, WM_GRAPHNOTIFY, 0);
  228. return true;
  229. }
  230. return false;
  231. }
  233. void CDXGraph::HandleEvent(WPARAM inWParam, LPARAM inLParam)
  234. {
  235. if (mEvent)
  236. {
  237. LONG eventCode = 0, eventParam1 = 0, eventParam2 = 0;
  238. while (SUCCEEDED(mEvent->GetEvent(&eventCode, &eventParam1, &eventParam2, 0)))
  239. {
  240. mEvent->FreeEventParams(eventCode, eventParam1, eventParam2);
  241. switch (eventCode)
  242. {
  243. case EC_COMPLETE:
  244. break;
  246. case EC_USERABORT:
  247. case EC_ERRORABORT:
  248. break;
  250. default:
  251. break;
  252. }
  253. }
  254. }
  255. }
  257. bool CDXGraph::Run(void)
  258. {
  259. if (mGraph && mMediaControl)
  260. {
  261. if (!IsRunning())
  262. {
  263. if (SUCCEEDED(mMediaControl->Run()))
  264. {
  265. return true;
  266. }
  267. }
  268. else
  269. {
  270. return true;
  271. }
  272. }
  273. return false;
  274. }
  276. bool CDXGraph::Stop(void)
  277. {
  278. if (mGraph && mMediaControl)
  279. {
  280. if (!IsStopped())
  281. {
  282. if (SUCCEEDED(mMediaControl->Stop()))
  283. {
  284. return true;
  285. }
  286. }
  287. else
  288. {
  289. return true;
  290. }
  291. }
  292. return false;
  293. }
  295. bool CDXGraph::Pause(void)
  296. {
  297. if (mGraph && mMediaControl)
  298. {
  299. if (!IsPaused())
  300. {
  301. if (SUCCEEDED(mMediaControl->Pause()))
  302. {
  303. return true;
  304. }
  305. }
  306. else
  307. {
  308. return true;
  309. }
  310. }
  311. return false;
  312. }
  314. bool CDXGraph::IsRunning(void)
  315. {
  316. if (mGraph && mMediaControl)
  317. {
  318. OAFilterState state = State_Stopped;
  319. if (SUCCEEDED(mMediaControl->GetState(10, &state)))
  320. {
  321. return state == State_Running;
  322. }
  323. }
  324. return false;
  325. }
  327. bool CDXGraph::IsStopped(void)
  328. {
  329. if (mGraph && mMediaControl)
  330. {
  331. OAFilterState state = State_Stopped;
  332. if (SUCCEEDED(mMediaControl->GetState(10, &state)))
  333. {
  334. return state == State_Stopped;
  335. }
  336. }
  337. return false;
  338. }
  340. bool CDXGraph::IsPaused(void)
  341. {
  342. if (mGraph && mMediaControl)
  343. {
  344. OAFilterState state = State_Stopped;
  345. if (SUCCEEDED(mMediaControl->GetState(10, &state)))
  346. {
  347. return state == State_Paused;
  348. }
  349. }
  350. return false;
  351. }
  353. bool CDXGraph::SetFullScreen(BOOL inEnabled)
  354. {
  355. if (mVideoWindow)
  356. {
  357. HRESULT hr = mVideoWindow->put_FullScreenMode(inEnabled ? OATRUE : OAFALSE);
  358. return SUCCEEDED(hr);
  359. }
  360. return false;
  361. }
  363. bool CDXGraph::GetFullScreen(void)
  364. {
  365. if (mVideoWindow)
  366. {
  367. long  fullScreenMode = OAFALSE;
  368. mVideoWindow->get_FullScreenMode(&fullScreenMode);
  369. return (fullScreenMode == OATRUE);
  370. }
  371. return false;
  372. }
  374. // IMediaSeeking features
  375. bool CDXGraph::GetCurrentPosition(double * outPosition)
  376. {
  377. if (mSeeking)
  378. {
  379. __int64 position = 0;
  380. if (SUCCEEDED(mSeeking->GetCurrentPosition(&position)))
  381. {
  382. *outPosition = ((double)position) / 10000000.;
  383. return true;
  384. }
  385. }
  386. return false;
  387. }
  389. bool CDXGraph::GetStopPosition(double * outPosition)
  390. {
  391. if (mSeeking)
  392. {
  393. __int64 position = 0;
  394. if (SUCCEEDED(mSeeking->GetStopPosition(&position)))
  395. {
  396. *outPosition = ((double)position) / 10000000.;
  397. return true;
  398. }
  399. }
  400. return false;
  401. }
  403. bool CDXGraph::SetCurrentPosition(double inPosition)
  404. {
  405. if (mSeeking)
  406. {
  407. __int64 one = 10000000;
  408. __int64 position = (__int64)(one * inPosition);
  409. HRESULT hr = mSeeking->SetPositions(&position, AM_SEEKING_AbsolutePositioning | AM_SEEKING_SeekToKeyFrame, 
  410. 0, AM_SEEKING_NoPositioning);
  411. return SUCCEEDED(hr);
  412. }
  413. return false;
  414. }
  416. bool CDXGraph::SetStartStopPosition(double inStart, double inStop)
  417. {
  418. if (mSeeking)
  419. {
  420. __int64 one = 10000000;
  421. __int64 startPos = (__int64)(one * inStart);
  422. __int64 stopPos  = (__int64)(one * inStop);
  423. HRESULT hr = mSeeking->SetPositions(&startPos, AM_SEEKING_AbsolutePositioning | AM_SEEKING_SeekToKeyFrame, 
  424. &stopPos, AM_SEEKING_AbsolutePositioning | AM_SEEKING_SeekToKeyFrame);
  425. return SUCCEEDED(hr);
  426. }
  427. return false;
  428. }
  430. bool CDXGraph::GetDuration(double * outDuration)
  431. {
  432. if (mSeeking)
  433. {
  434. __int64 length = 0;
  435. if (SUCCEEDED(mSeeking->GetDuration(&length)))
  436. {
  437. *outDuration = ((double)length) / 10000000.;
  438. return true;
  439. }
  440. }
  441. return false;
  442. }
  444. bool CDXGraph::SetPlaybackRate(double inRate)
  445. {
  446. if (mSeeking)
  447. {
  448. if (SUCCEEDED(mSeeking->SetRate(inRate)))
  449. {
  450. return true;
  451. }
  452. }
  453. return false;
  454. }
  456. bool CDXGraph::RenderFile(const char * inFile)
  457. {
  458. if (mGraph)
  459. {
  460. WCHAR    szFilePath[MAX_PATH];
  461. MultiByteToWideChar(CP_ACP, 0, inFile, -1, szFilePath, MAX_PATH);
  462. if (SUCCEEDED(mGraph->RenderFile(szFilePath, NULL)))
  463. {
  464. return true;
  465. }
  466. }
  467. return false;
  468. }
  471. //////////////////////// For GraphEdit Dubug purpose /////////////////////////////
  472. void CDXGraph::AddToObjectTable(void)
  473. {
  474. IMoniker * pMoniker = 0;
  475.     IRunningObjectTable * objectTable = 0;
  476.     if (SUCCEEDED(GetRunningObjectTable(0, &objectTable))) 
  477. {
  478. WCHAR wsz[256];
  479. wsprintfW(wsz, L"FilterGraph %08p pid %08x", (DWORD_PTR)mGraph, GetCurrentProcessId());
  480. HRESULT hr = CreateItemMoniker(L"!", wsz, &pMoniker);
  481. if (SUCCEEDED(hr)) 
  482. {
  483. hr = objectTable->Register(0, mGraph, pMoniker, &mObjectTableEntry);
  484. pMoniker->Release();
  485. }
  486. objectTable->Release();
  487. }
  488. }
  490. void CDXGraph::RemoveFromObjectTable(void)
  491. {
  492. IRunningObjectTable * objectTable = 0;
  493.     if (SUCCEEDED(GetRunningObjectTable(0, &objectTable))) 
  494. {
  495.         objectTable->Revoke(mObjectTableEntry);
  496.         objectTable->Release();
  497. mObjectTableEntry = 0;
  498.     }
  499. }