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

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

DirextX编程

开发平台：

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. void CDXGraph::Release(void)
  71. {
  72. if (mSeeking)
  73. {
  74. mSeeking->Release();
  75. mSeeking = NULL;
  76. }
  77. if (mMediaControl)
  78. {
  79. mMediaControl->Release();
  80. mMediaControl = NULL;
  81. }
  82. if (mEvent)
  83. {
  84. mEvent->Release();
  85. mEvent = NULL;
  86. }
  87. if (mBasicVideo)
  88. {
  89. mBasicVideo->Release();
  90. mBasicVideo = NULL;
  91. }
  92. if (mBasicAudio)
  93. {
  94. mBasicAudio->Release();
  95. mBasicAudio = NULL;
  96. }
  97. if (mVideoWindow)
  98. {
  99. mVideoWindow->put_Visible(OAFALSE);
  100. mVideoWindow->put_MessageDrain((OAHWND)NULL);
  101. mVideoWindow->put_Owner(OAHWND(0));
  102. mVideoWindow->Release();
  103. mVideoWindow = NULL;
  104. }
  105. RemoveFromObjectTable();
  106. if (mGraph) 
  107. {
  108. mGraph->Release(); 
  109. mGraph = NULL;
  110. }
  111. }
  113. bool CDXGraph::Attach(IGraphBuilder * inGraphBuilder)
  114. {
  115. Release();
  117. if (inGraphBuilder)
  118. {
  119. inGraphBuilder->AddRef();
  120. mGraph = inGraphBuilder;
  122. AddToObjectTable();
  123. return QueryInterfaces();
  124. }
  125. return true;
  126. }
  128. IGraphBuilder * CDXGraph::GetGraph(void)
  129. {
  130. return mGraph;
  131. }
  133. IMediaEventEx * CDXGraph::GetEventHandle(void)
  134. {
  135. return mEvent;
  136. }
  138. // Connect filter from the upstream output pin to the downstream input pin
  139. bool CDXGraph::ConnectFilters(IPin * inOutputPin, IPin * inInputPin, 
  140.   const AM_MEDIA_TYPE * inMediaType)
  141. {
  142. if (mGraph && inOutputPin && inInputPin)
  143. {
  144. HRESULT hr = mGraph->ConnectDirect(inOutputPin, inInputPin, inMediaType);
  145. return SUCCEEDED(hr) ? true : false;
  146. }
  147. return false;
  148. }
  150. void CDXGraph::DisconnectFilters(IPin * inOutputPin)
  151. {
  152. if (mGraph && inOutputPin)
  153. {
  154. HRESULT hr = mGraph->Disconnect(inOutputPin);
  155. }
  156. }
  158. bool CDXGraph::SetDisplayWindow(HWND inWindow)
  159. {
  160. if (mVideoWindow)
  161. {
  162. // long lVisible;
  163. // mVideoWindow->get_Visible(&lVisible);
  164. // Hide the video window first
  165. mVideoWindow->put_Visible(OAFALSE);
  166. mVideoWindow->put_Owner((OAHWND)inWindow);
  168. RECT windowRect;
  169. ::GetClientRect(inWindow, &windowRect);
  170. mVideoWindow->put_Left(0);
  171. mVideoWindow->put_Top(0);
  172. mVideoWindow->put_Width(windowRect.right - windowRect.left);
  173. mVideoWindow->put_Height(windowRect.bottom - windowRect.top);
  174. mVideoWindow->put_WindowStyle(WS_CHILD|WS_CLIPCHILDREN|WS_CLIPSIBLINGS);
  176. mVideoWindow->put_MessageDrain((OAHWND) inWindow);
  177. // Restore the video window
  178. if (inWindow != NULL)
  179. {
  180. // mVideoWindow->put_Visible(lVisible);
  181. mVideoWindow->put_Visible(OATRUE);
  182. }
  183. else
  184. {
  185. mVideoWindow->put_Visible(OAFALSE);
  186. }
  187. return true;
  188. }
  189. return false;
  190. }
  192. bool CDXGraph::ResizeVideoWindow(long inLeft, long inTop, long inWidth, long inHeight)
  193. {
  194. if (mVideoWindow)
  195. {
  196. long lVisible = OATRUE;
  197. mVideoWindow->get_Visible(&lVisible);
  198. // Hide the video window first
  199. mVideoWindow->put_Visible(OAFALSE);
  201. mVideoWindow->put_Left(inLeft);
  202. mVideoWindow->put_Top(inTop);
  203. mVideoWindow->put_Width(inWidth);
  204. mVideoWindow->put_Height(inHeight);
  206. // Restore the video window
  207. mVideoWindow->put_Visible(lVisible);
  208. return true;
  209. }
  210. return false;
  211. }
  213. bool CDXGraph::SetNotifyWindow(HWND inWindow)
  214. {
  215. if (mEvent)
  216. {
  217. mEvent->SetNotifyWindow((OAHWND)inWindow, WM_GRAPHNOTIFY, 0);
  218. return true;
  219. }
  220. return false;
  221. }
  223. void CDXGraph::HandleEvent(WPARAM inWParam, LPARAM inLParam)
  224. {
  225. if (mEvent)
  226. {
  227. LONG eventCode = 0, eventParam1 = 0, eventParam2 = 0;
  228. while (SUCCEEDED(mEvent->GetEvent(&eventCode, &eventParam1, &eventParam2, 0)))
  229. {
  230. mEvent->FreeEventParams(eventCode, eventParam1, eventParam2);
  231. switch (eventCode)
  232. {
  233. case EC_COMPLETE:
  234. break;
  236. case EC_USERABORT:
  237. case EC_ERRORABORT:
  238. break;
  240. default:
  241. break;
  242. }
  243. }
  244. }
  245. }
  247. bool CDXGraph::Run(void)
  248. {
  249. if (mGraph && mMediaControl)
  250. {
  251. if (!IsRunning())
  252. {
  253. if (SUCCEEDED(mMediaControl->Run()))
  254. {
  255. return true;
  256. }
  257. }
  258. else
  259. {
  260. return true;
  261. }
  262. }
  263. return false;
  264. }
  266. bool CDXGraph::Stop(void)
  267. {
  268. if (mGraph && mMediaControl)
  269. {
  270. if (!IsStopped())
  271. {
  272. if (SUCCEEDED(mMediaControl->Stop()))
  273. {
  274. return true;
  275. }
  276. }
  277. else
  278. {
  279. return true;
  280. }
  281. }
  282. return false;
  283. }
  285. bool CDXGraph::Pause(void)
  286. {
  287. if (mGraph && mMediaControl)
  288. {
  289. if (!IsPaused())
  290. {
  291. if (SUCCEEDED(mMediaControl->Pause()))
  292. {
  293. return true;
  294. }
  295. }
  296. else
  297. {
  298. return true;
  299. }
  300. }
  301. return false;
  302. }
  304. bool CDXGraph::IsRunning(void)
  305. {
  306. if (mGraph && mMediaControl)
  307. {
  308. OAFilterState state = State_Stopped;
  309. if (SUCCEEDED(mMediaControl->GetState(10, &state)))
  310. {
  311. return state == State_Running;
  312. }
  313. }
  314. return false;
  315. }
  317. bool CDXGraph::IsStopped(void)
  318. {
  319. if (mGraph && mMediaControl)
  320. {
  321. OAFilterState state = State_Stopped;
  322. if (SUCCEEDED(mMediaControl->GetState(10, &state)))
  323. {
  324. return state == State_Stopped;
  325. }
  326. }
  327. return false;
  328. }
  330. bool CDXGraph::IsPaused(void)
  331. {
  332. if (mGraph && mMediaControl)
  333. {
  334. OAFilterState state = State_Stopped;
  335. if (SUCCEEDED(mMediaControl->GetState(10, &state)))
  336. {
  337. return state == State_Paused;
  338. }
  339. }
  340. return false;
  341. }
  343. bool CDXGraph::SetFullScreen(BOOL inEnabled)
  344. {
  345. if (mVideoWindow)
  346. {
  347. HRESULT hr = mVideoWindow->put_FullScreenMode(inEnabled ? OATRUE : OAFALSE);
  348. return SUCCEEDED(hr);
  349. }
  350. return false;
  351. }
  353. bool CDXGraph::GetFullScreen(void)
  354. {
  355. if (mVideoWindow)
  356. {
  357. long  fullScreenMode = OAFALSE;
  358. mVideoWindow->get_FullScreenMode(&fullScreenMode);
  359. return (fullScreenMode == OATRUE);
  360. }
  361. return false;
  362. }
  364. // IMediaSeeking features
  365. bool CDXGraph::GetCurrentPosition(double * outPosition)
  366. {
  367. if (mSeeking)
  368. {
  369. __int64 position = 0;
  370. if (SUCCEEDED(mSeeking->GetCurrentPosition(&position)))
  371. {
  372. *outPosition = ((double)position) / 10000000.;
  373. return true;
  374. }
  375. }
  376. return false;
  377. }
  379. bool CDXGraph::GetStopPosition(double * outPosition)
  380. {
  381. if (mSeeking)
  382. {
  383. __int64 position = 0;
  384. if (SUCCEEDED(mSeeking->GetStopPosition(&position)))
  385. {
  386. *outPosition = ((double)position) / 10000000.;
  387. return true;
  388. }
  389. }
  390. return false;
  391. }
  393. bool CDXGraph::SetCurrentPosition(double inPosition)
  394. {
  395. if (mSeeking)
  396. {
  397. __int64 one = 10000000;
  398. __int64 position = (__int64)(one * inPosition);
  399. HRESULT hr = mSeeking->SetPositions(&position, AM_SEEKING_AbsolutePositioning | AM_SEEKING_SeekToKeyFrame, 
  400. 0, AM_SEEKING_NoPositioning);
  401. return SUCCEEDED(hr);
  402. }
  403. return false;
  404. }
  406. bool CDXGraph::SetStartStopPosition(double inStart, double inStop)
  407. {
  408. if (mSeeking)
  409. {
  410. __int64 one = 10000000;
  411. __int64 startPos = (__int64)(one * inStart);
  412. __int64 stopPos  = (__int64)(one * inStop);
  413. HRESULT hr = mSeeking->SetPositions(&startPos, AM_SEEKING_AbsolutePositioning | AM_SEEKING_SeekToKeyFrame, 
  414. &stopPos, AM_SEEKING_AbsolutePositioning | AM_SEEKING_SeekToKeyFrame);
  415. return SUCCEEDED(hr);
  416. }
  417. return false;
  418. }
  420. bool CDXGraph::GetDuration(double * outDuration)
  421. {
  422. if (mSeeking)
  423. {
  424. __int64 length = 0;
  425. if (SUCCEEDED(mSeeking->GetDuration(&length)))
  426. {
  427. *outDuration = ((double)length) / 10000000.;
  428. return true;
  429. }
  430. }
  431. return false;
  432. }
  434. bool CDXGraph::SetPlaybackRate(double inRate)
  435. {
  436. if (mSeeking)
  437. {
  438. if (SUCCEEDED(mSeeking->SetRate(inRate)))
  439. {
  440. return true;
  441. }
  442. }
  443. return false;
  444. }
  446. // Attention: range from -10000 to 0, and 0 is FULL_VOLUME.
  447. bool CDXGraph::SetAudioVolume(long inVolume)
  448. {
  449. if (mBasicAudio)
  450. {
  451. HRESULT hr = mBasicAudio->put_Volume(inVolume);
  452. return SUCCEEDED(hr);
  453. }
  454. return false;
  455. }
  457. long CDXGraph::GetAudioVolume(void)
  458. {
  459. long volume = 0;
  460. if (mBasicAudio)
  461. {
  462. mBasicAudio->get_Volume(&volume);
  463. }
  464. return volume;
  465. }
  467. // Attention: range from -10000(left) to 10000(right), and 0 is both.
  468. bool CDXGraph::SetAudioBalance(long inBalance)
  469. {
  470. if (mBasicAudio)
  471. {
  472. HRESULT hr = mBasicAudio->put_Balance(inBalance);
  473. return SUCCEEDED(hr);
  474. }
  475. return false;
  476. }
  478. long CDXGraph::GetAudioBalance(void)
  479. {
  480. long balance = 0;
  481. if (mBasicAudio)
  482. {
  483. mBasicAudio->get_Balance(&balance);
  484. }
  485. return balance;
  486. }
  488. bool CDXGraph::RenderFile(const char * inFile)
  489. {
  490. if (mGraph)
  491. {
  492. WCHAR    szFilePath[MAX_PATH];
  493. MultiByteToWideChar(CP_ACP, 0, inFile, -1, szFilePath, MAX_PATH);
  494. if (SUCCEEDED(mGraph->RenderFile(szFilePath, NULL)))
  495. {
  496. return true;
  497. }
  498. }
  499. return false;
  500. }
  502. bool CDXGraph::SnapshotBitmap(const char * outFile)
  503. {
  504. if (mBasicVideo)
  505. {
  506. long bitmapSize = 0;
  507. if (SUCCEEDED(mBasicVideo->GetCurrentImage(&bitmapSize, 0)))
  508. {
  509. bool pass = false;
  510. unsigned char * buffer = new unsigned char[bitmapSize];
  511. if (SUCCEEDED(mBasicVideo->GetCurrentImage(&bitmapSize, (long *)buffer)))
  512. {
  513. BITMAPFILEHEADER hdr;
  514. LPBITMAPINFOHEADER lpbi;
  516. lpbi = (LPBITMAPINFOHEADER)buffer;
  518. int nColors = 1 << lpbi->biBitCount;
  519. if (nColors > 256)
  520. nColors = 0;
  522. hdr.bfType = ((WORD) ('M' << 8) | 'B'); //always is "BM"
  523. hdr.bfSize = bitmapSize + sizeof( hdr );
  524. hdr.bfReserved1  = 0;
  525. hdr.bfReserved2  = 0;
  526. hdr.bfOffBits = (DWORD) (sizeof(BITMAPFILEHEADER) + lpbi->biSize +
  527. nColors * sizeof(RGBQUAD));
  529. CFile bitmapFile(outFile, CFile::modeReadWrite | CFile::modeCreate | CFile::typeBinary);
  530. bitmapFile.Write(&hdr, sizeof(BITMAPFILEHEADER));
  531. bitmapFile.Write(buffer, bitmapSize);
  532. bitmapFile.Close();
  533. pass = true;
  534. }
  535. delete [] buffer;
  536. return pass;
  537. }
  538. }
  539. return false;
  540. }
  544. //////////////////////// For GraphEdit Dubug purpose /////////////////////////////
  545. void CDXGraph::AddToObjectTable(void)
  546. {
  547. IMoniker * pMoniker = 0;
  548.     IRunningObjectTable * objectTable = 0;
  549.     if (SUCCEEDED(GetRunningObjectTable(0, &objectTable))) 
  550. {
  551. WCHAR wsz[256];
  552. wsprintfW(wsz, L"FilterGraph %08p pid %08x", (DWORD_PTR)mGraph, GetCurrentProcessId());
  553. HRESULT hr = CreateItemMoniker(L"!", wsz, &pMoniker);
  554. if (SUCCEEDED(hr)) 
  555. {
  556. hr = objectTable->Register(0, mGraph, pMoniker, &mObjectTableEntry);
  557. pMoniker->Release();
  558. }
  559. objectTable->Release();
  560. }
  561. }
  563. void CDXGraph::RemoveFromObjectTable(void)
  564. {
  565. IRunningObjectTable * objectTable = 0;
  566.     if (SUCCEEDED(GetRunningObjectTable(0, &objectTable))) 
  567. {
  568.         objectTable->Revoke(mObjectTableEntry);
  569.         objectTable->Release();
  570. mObjectTableEntry = 0;
  571.     }
  572. }