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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > DirextX编程 > 查看源码
CDXGraph.cpp
资源名称：DirectShowcode.rar　[点击查看]
上传用户：hhs829
上传日期：2022-06-17
资源大小：586k
文件大小：9k
源码类别：

DirextX编程

开发平台：

Visual C++

CDXGraph.cpp：源码内容
  1. //
  2. // CDXGraph.cpp
  3. //
  5. #include "stdafx.h"
  6. #include "CDXGraph.h"
  8. #ifdef _DEBUG
  9. #define new DEBUG_NEW
  10. #undef THIS_FILE
  11. static char THIS_FILE[] = __FILE__;
  12. #endif
  14. ////////////////////////////////////////////////////////////////////////////////
  15. CDXGraph::CDXGraph()
  16. {
  17. mGraph        = 0;
  18. mMediaControl = 0;
  19. mEvent        = 0;
  20. mBasicVideo   = 0;
  21. mBasicAudio   = 0;
  22. mVideoWindow  = 0;
  23. mSeeking      = 0;
  25. mObjectTableEntry = 0;
  26. }
  28. CDXGraph::~CDXGraph()
  29. {
  30. Release();
  31. }
  33. bool CDXGraph::Create(void)
  34. {
  35. if (!mGraph)
  36. {
  37. if (SUCCEEDED(CoCreateInstance(CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER,
  38. IID_IGraphBuilder, (void **)&mGraph)))
  39. {
  40. AddToObjectTable();
  42. return QueryInterfaces();
  43. }
  44. mGraph = 0;
  45. }
  46. return false;
  47. }
  49. bool CDXGraph::QueryInterfaces(void)
  50. {
  51. if (mGraph)
  52. {
  53. HRESULT hr = NOERROR;
  54. hr |= mGraph->QueryInterface(IID_IMediaControl, (void **)&mMediaControl);
  55. hr |= mGraph->QueryInterface(IID_IMediaEventEx, (void **)&mEvent);
  56. hr |= mGraph->QueryInterface(IID_IBasicVideo, (void **)&mBasicVideo);
  57. hr |= mGraph->QueryInterface(IID_IBasicAudio, (void **)&mBasicAudio);
  58. hr |= mGraph->QueryInterface(IID_IVideoWindow, (void **)&mVideoWindow);
  59. hr |= mGraph->QueryInterface(IID_IMediaSeeking, (void **)&mSeeking);
  60. if (mSeeking)
  61. {
  62. mSeeking->SetTimeFormat(&TIME_FORMAT_MEDIA_TIME);
  63. }
  64. return SUCCEEDED(hr);
  65. }
  66. return false;
  67. }
  69. void CDXGraph::Release(void)
  70. {
  71. if (mSeeking)
  72. {
  73. mSeeking->Release();
  74. mSeeking = 0;
  75. }
  76. if (mMediaControl)
  77. {
  78. mMediaControl->Release();
  79. mMediaControl = 0;
  80. }
  81. if (mEvent)
  82. {
  83. mEvent->Release();
  84. mEvent = 0;
  85. }
  86. if (mBasicVideo)
  87. {
  88. mBasicVideo->Release();
  89. mBasicVideo = 0;
  90. }
  91. if (mBasicAudio)
  92. {
  93. mBasicAudio->Release();
  94. mBasicAudio = 0;
  95. }
  96. if (mVideoWindow)
  97. {
  98. mVideoWindow->put_Visible(OAFALSE);
  99. mVideoWindow->put_MessageDrain((OAHWND)NULL);
  100. mVideoWindow->put_Owner(OAHWND(0));
  101. mVideoWindow->Release();
  102. mVideoWindow = 0;
  103. }
  104. RemoveFromObjectTable();
  105. if (mGraph) 
  106. {
  107. mGraph->Release(); 
  108. mGraph = 0;
  109. }
  110. }
  112. bool CDXGraph::Attach(IGraphBuilder * inGraphBuilder)
  113. {
  114. Release();
  116. if (inGraphBuilder)
  117. {
  118. inGraphBuilder->AddRef();
  119. mGraph = inGraphBuilder;
  121. AddToObjectTable();
  122. return QueryInterfaces();
  123. }
  124. return true;
  125. }
  127. IGraphBuilder * CDXGraph::GetGraph(void)
  128. {
  129. return mGraph;
  130. }
  132. // Connect filter from the upstream output pin to the downstream input pin
  133. bool CDXGraph::ConnectFilters(IPin * inOutputPin, IPin * inInputPin, 
  134.   const AM_MEDIA_TYPE * inMediaType)
  135. {
  136. if (mGraph && inOutputPin && inInputPin)
  137. {
  138. HRESULT hr = mGraph->ConnectDirect(inOutputPin, inInputPin, inMediaType);
  139. return SUCCEEDED(hr) ? true : false;
  140. }
  141. return false;
  142. }
  144. void CDXGraph::DisconnectFilters(IPin * inOutputPin)
  145. {
  146. if (mGraph && inOutputPin)
  147. {
  148. HRESULT hr = mGraph->Disconnect(inOutputPin);
  149. }
  150. }
  152. bool CDXGraph::SetDisplayWindow(HWND inWindow)
  153. {
  154. if (mVideoWindow)
  155. {
  156. // long lVisible;
  157. // mVideoWindow->get_Visible(&lVisible);
  158. // Hide the video window first
  159. mVideoWindow->put_Visible(OAFALSE);
  160. mVideoWindow->put_Owner((OAHWND)inWindow);
  162. RECT windowRect;
  163. ::GetClientRect(inWindow, &windowRect);
  164. mVideoWindow->put_Left(0);
  165. mVideoWindow->put_Top(0);
  166. mVideoWindow->put_Width(windowRect.right - windowRect.left);
  167. mVideoWindow->put_Height(windowRect.bottom - windowRect.top);
  168. mVideoWindow->put_WindowStyle(WS_CHILD|WS_CLIPCHILDREN|WS_CLIPSIBLINGS);
  170. mVideoWindow->put_MessageDrain((OAHWND) inWindow);
  171. // Restore the video window
  172. if (inWindow != NULL)
  173. {
  174. // mVideoWindow->put_Visible(lVisible);
  175. mVideoWindow->put_Visible(OATRUE);
  176. }
  177. else
  178. {
  179. mVideoWindow->put_Visible(OAFALSE);
  180. }
  181. return true;
  182. }
  183. return false;
  184. }
  186. bool CDXGraph::SetNotifyWindow(HWND inWindow)
  187. {
  188. if (mEvent)
  189. {
  190. mEvent->SetNotifyWindow((OAHWND)inWindow, WM_GRAPHNOTIFY, 0);
  191. return true;
  192. }
  193. return false;
  194. }
  196. void CDXGraph::HandleEvent(WPARAM inWParam, LPARAM inLParam)
  197. {
  198. if (mEvent)
  199. {
  200. LONG eventCode = 0, eventParam1 = 0, eventParam2 = 0;
  201. while (SUCCEEDED(mEvent->GetEvent(&eventCode, &eventParam1, &eventParam2, 0)))
  202. {
  203. mEvent->FreeEventParams(eventCode, eventParam1, eventParam2);
  204. switch (eventCode)
  205. {
  206. case EC_COMPLETE:
  207. break;
  209. case EC_USERABORT:
  210. break;
  212. case EC_ERRORABORT:
  213. break;
  215. default:
  216. break;
  217. }
  218. }
  219. }
  220. }
  222. bool CDXGraph::Run(void)
  223. {
  224. if (mGraph && mMediaControl)
  225. {
  226. if (!IsRunning())
  227. {
  228. if (SUCCEEDED(mMediaControl->Run()))
  229. {
  230. return true;
  231. }
  232. }
  233. else
  234. {
  235. return true;
  236. }
  237. }
  238. return false;
  239. }
  241. bool CDXGraph::Stop(void)
  242. {
  243. if (mGraph && mMediaControl)
  244. {
  245. if (!IsStopped())
  246. {
  247. if (SUCCEEDED(mMediaControl->Stop()))
  248. {
  249. return true;
  250. }
  251. }
  252. }
  253. return false;
  254. }
  256. bool CDXGraph::Pause(void)
  257. {
  258. if (mGraph && mMediaControl)
  259. {
  260. if (!IsPaused())
  261. {
  262. if (SUCCEEDED(mMediaControl->Pause()))
  263. {
  264. return true;
  265. }
  266. }
  267. else
  268. {
  269. return true;
  270. }
  271. }
  272. return false;
  273. }
  275. bool CDXGraph::IsRunning(void)
  276. {
  277. if (mGraph && mMediaControl)
  278. {
  279. OAFilterState state = State_Stopped;
  280. if (SUCCEEDED(mMediaControl->GetState(10, &state)))
  281. {
  282. return state == State_Running;
  283. }
  284. }
  285. return false;
  286. }
  288. bool CDXGraph::IsStopped(void)
  289. {
  290. if (mGraph && mMediaControl)
  291. {
  292. OAFilterState state = State_Stopped;
  293. if (SUCCEEDED(mMediaControl->GetState(10, &state)))
  294. {
  295. return state == State_Stopped;
  296. }
  297. }
  298. return false;
  299. }
  301. bool CDXGraph::IsPaused(void)
  302. {
  303. if (mGraph && mMediaControl)
  304. {
  305. OAFilterState state = State_Stopped;
  306. if (SUCCEEDED(mMediaControl->GetState(10, &state)))
  307. {
  308. return state == State_Paused;
  309. }
  310. }
  311. return false;
  312. }
  314. bool CDXGraph::SetFullScreen(BOOL inEnabled)
  315. {
  316. if (mVideoWindow)
  317. {
  318. HRESULT hr = mVideoWindow->put_FullScreenMode(inEnabled ? OATRUE : OAFALSE);
  319. return SUCCEEDED(hr);
  320. }
  321. return false;
  322. }
  324. bool CDXGraph::GetFullScreen(void)
  325. {
  326. if (mVideoWindow)
  327. {
  328. long  fullScreenMode = OAFALSE;
  329. mVideoWindow->get_FullScreenMode(&fullScreenMode);
  330. return (fullScreenMode == OATRUE);
  331. }
  332. return false;
  333. }
  335. bool CDXGraph::SetSyncSource(IBaseFilter * inFilter)
  336. {
  337. if (inFilter)
  338. {
  339. IReferenceClock *pClock = 0;
  340. inFilter->QueryInterface(IID_IReferenceClock, (void**)&pClock);
  341. if (pClock)
  342. {
  343. // Set the graph clock.
  344. IMediaFilter *pMediaFilter = 0;
  345. mGraph->QueryInterface(IID_IMediaFilter, (void**)&pMediaFilter);
  346. pMediaFilter->SetSyncSource(pClock);
  347. pClock->Release();
  348. pMediaFilter->Release();
  349. return true;
  350. }
  351. return false;
  352. }
  353. else
  354. {
  355. // Do not use any reference clock
  356. IMediaFilter *pMediaFilter = 0;
  357. mGraph->QueryInterface(IID_IMediaFilter, (void**)&pMediaFilter);
  358. pMediaFilter->SetSyncSource(NULL);
  359. pMediaFilter->Release();
  360. return true;
  361. }
  362. }
  364. bool CDXGraph::SetDefaultSyncSource(void)
  365. {
  366. if (mGraph)
  367. {
  368. HRESULT hr = mGraph->SetDefaultSyncSource();
  369. return SUCCEEDED(hr) ?  true : false;
  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::SetCurrentPosition(double inPosition)
  390. {
  391. if (mSeeking)
  392. {
  393. __int64 one = 10000000;
  394. __int64 position = (__int64)(one * inPosition);
  395. HRESULT hr = mSeeking->SetPositions(&position, AM_SEEKING_AbsolutePositioning | AM_SEEKING_SeekToKeyFrame, 
  396. 0, AM_SEEKING_NoPositioning);
  397. return SUCCEEDED(hr);
  398. }
  399. return false;
  400. }
  402. bool CDXGraph::GetDuration(double * outDuration)
  403. {
  404. if (mSeeking)
  405. {
  406. __int64 length = 0;
  407. if (SUCCEEDED(mSeeking->GetDuration(&length)))
  408. {
  409. *outDuration = ((double)length) / 10000000.;
  410. return true;
  411. }
  412. }
  413. return false;
  414. }
  416. bool CDXGraph::RenderFile(const char * inFile)
  417. {
  418. if (mGraph)
  419. {
  420. WCHAR    szFilePath[MAX_PATH];
  421. MultiByteToWideChar(CP_ACP, 0, inFile, -1, szFilePath, MAX_PATH);
  422. if (SUCCEEDED(mGraph->RenderFile(szFilePath, NULL)))
  423. {
  424. return true;
  425. }
  426. }
  427. return false;
  428. }
  430. bool CDXGraph::WaitForCompletion(void)
  431. {
  432. if (mEvent && IsRunning())
  433. {
  434. long  eventCode = 0;
  435. HRESULT hr = mEvent->WaitForCompletion(INFINITE, &eventCode);
  436. return SUCCEEDED(hr);
  437. }
  438. return true;
  439. }
  443. //////////////////////// For GraphEdit Dubug purpose /////////////////////////////
  444. void CDXGraph::AddToObjectTable(void)
  445. {
  446. IMoniker * pMoniker = 0;
  447.     IRunningObjectTable * objectTable = 0;
  448.     if (SUCCEEDED(GetRunningObjectTable(0, &objectTable))) 
  449. {
  450. WCHAR wsz[256];
  451. wsprintfW(wsz, L"FilterGraph %08p pid %08x", (DWORD_PTR)mGraph, GetCurrentProcessId());
  452. HRESULT hr = CreateItemMoniker(L"!", wsz, &pMoniker);
  453. if (SUCCEEDED(hr)) 
  454. {
  455. hr = objectTable->Register(0, mGraph, pMoniker, &mObjectTableEntry);
  456. pMoniker->Release();
  457. }
  458. objectTable->Release();
  459. }
  460. }
  462. void CDXGraph::RemoveFromObjectTable(void)
  463. {
  464. IRunningObjectTable * objectTable = 0;
  465.     if (SUCCEEDED(GetRunningObjectTable(0, &objectTable))) 
  466. {
  467.         objectTable->Revoke(mObjectTableEntry);
  468.         objectTable->Release();
  469. mObjectTableEntry = 0;
  470.     }
  471. }