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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
PlayerCaptureDialog.cpp
资源名称：fullMPCcode.rar　[点击查看]
上传用户：xjjlds
上传日期：2015-12-05
资源大小：22823k
文件大小：44k
源码类别：

多媒体编程

开发平台：

Visual C++

PlayerCaptureDialog.cpp：源码内容
  1. /* 
  2.  * Copyright (C) 2003-2005 Gabest
  3.  * http://www.gabest.org
  4.  *
  5.  *  This Program is free software; you can redistribute it and/or modify
  6.  *  it under the terms of the GNU General Public License as published by
  7.  *  the Free Software Foundation; either version 2, or (at your option)
  8.  *  any later version.
  9.  *   
  10.  *  This Program is distributed in the hope that it will be useful,
  11.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13.  *  GNU General Public License for more details.
  14.  *   
  15.  *  You should have received a copy of the GNU General Public License
  16.  *  along with GNU Make; see the file COPYING.  If not, write to
  17.  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 
  18.  *  http://www.gnu.org/copyleft/gpl.html
  19.  *
  20.  */
  22. // PlayerCaptureDialog.cpp : implementation file
  23. //
  25. #include "stdafx.h"
  26. #include "mplayerc.h"
  27. #include "mainfrm.h"
  28. #include "PlayerCaptureDialog.h"
  29. #include "....DSUtilDSUtil.h"
  30. #include "......includeOggOggDS.h"
  31. #include "....filtersmuxerwavdestwavdest.h"
  32. #include "....filtersmuxerMatroskaMuxerMatroskaMuxer.h"
  33. #include "....filtersmuxerDSMMuxerDSMMuxer.h"
  34. #include ".playercapturedialog.h"
  36. static bool LoadMediaType(CStringW DisplayName, AM_MEDIA_TYPE** ppmt)
  37. {
  38. bool fRet = false;
  40. if(!ppmt) return(fRet);
  42. *ppmt = (AM_MEDIA_TYPE*)CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE));
  43. if(!*ppmt) return(fRet);
  45. memset(*ppmt, 0, sizeof(AM_MEDIA_TYPE));
  47. BYTE* pData;
  48. UINT len;
  49. if(AfxGetApp()->GetProfileBinary(_T("Capture\") + CString(DisplayName), _T("MediaType"), &pData, &len))
  50. {
  51. if(len != sizeof(AM_MEDIA_TYPE)) return(fRet);
  52. memcpy(*ppmt, pData, len);
  53. delete [] pData;
  55. (*ppmt)->cbFormat = 0;
  56. (*ppmt)->pbFormat = NULL;
  58. fRet = true;
  60. if(AfxGetApp()->GetProfileBinary(_T("Capture\") + CString(DisplayName), _T("Format"), &pData, &len))
  61. {
  62. if(!len) return(fRet);
  63. (*ppmt)->cbFormat = len;
  64. (*ppmt)->pbFormat = (BYTE*)CoTaskMemAlloc(len);
  65. memcpy((*ppmt)->pbFormat, pData, len);
  66. delete [] pData;
  68. }
  69. }
  71. return(fRet);
  72. }
  74. static void SaveMediaType(CStringW DisplayName, AM_MEDIA_TYPE* pmt)
  75. {
  76. if(DisplayName.IsEmpty() || !pmt) return;
  78. AfxGetApp()->WriteProfileBinary(_T("Capture\") + CString(DisplayName), _T("MediaType"), (BYTE*)pmt, sizeof(AM_MEDIA_TYPE));
  79. AfxGetApp()->WriteProfileBinary(_T("Capture\") + CString(DisplayName), _T("Format"), pmt->pbFormat, pmt->cbFormat);
  80. }
  82. static void LoadDefaultCodec(CArray<Codec>& codecs, CComboBox& box, const GUID& cat)
  83. {
  84. int len = box.GetCount();
  85. if(len >= 0) box.SetCurSel(0);
  87. if(cat == GUID_NULL) return;
  89. CString DisplayName = AfxGetApp()->GetProfileString(_T("Capture\") + CStringFromGUID(cat), _T("DisplayName"));
  91. for(int i = 0; i < len; i++)
  92. {
  93. int iSel = box.GetItemData(i);
  94. if(iSel < 0) continue;
  96. Codec& c = codecs[iSel];
  97. if(DisplayName == c.DisplayName)
  98. {
  99. box.SetCurSel(i);
  100. if(!c.pBF)
  101. c.pMoniker->BindToObject(NULL, NULL, __uuidof(IBaseFilter), (void**)&c.pBF);
  102. break;
  103. }
  104. }
  105. }
  107. static void SaveDefaultCodec(CArray<Codec>& codecs, CComboBox& box, const GUID& cat)
  108. {
  109. if(cat == GUID_NULL) return;
  111. CString guid = CStringFromGUID(cat);
  113. AfxGetApp()->WriteProfileString(_T("Capture\") + guid, NULL, NULL);
  115. int iSel = box.GetCurSel();
  116. if(iSel < 0) return;
  117. iSel = box.GetItemData(iSel);
  118. if(iSel < 0) return;
  120. Codec& codec = codecs[iSel];
  122. AfxGetApp()->WriteProfileString(_T("Capture\") + guid, _T("DisplayName"), CString(codec.DisplayName));
  123. }
  125. static void SetupDefaultCaps(AM_MEDIA_TYPE* pmt, VIDEO_STREAM_CONFIG_CAPS& caps)
  126. {
  127. memset(&caps, 0, sizeof(caps));
  129. if(!pmt) return;
  131. VIDEOINFOHEADER* vih = (VIDEOINFOHEADER*)pmt->pbFormat;
  133. BITMAPINFOHEADER* bih = (pmt->formattype == FORMAT_VideoInfo)
  134. ? &((VIDEOINFOHEADER*)pmt->pbFormat)->bmiHeader
  135. : (pmt->formattype == FORMAT_VideoInfo2)
  136. ? &((VIDEOINFOHEADER2*)pmt->pbFormat)->bmiHeader
  137. : NULL;
  139.     caps.guid = GUID_NULL;
  140.     caps.VideoStandard = 0;
  141. caps.InputSize.cx = bih->biWidth;
  142. caps.InputSize.cy = abs(bih->biHeight);
  143.     caps.MinCroppingSize = caps.MaxCroppingSize = caps.InputSize;
  144.     caps.CropGranularityX = caps.CropGranularityY = 1;
  145.     caps.CropAlignX = caps.CropAlignY = 1;
  146.     caps.MinOutputSize = CSize(64, 64);
  147.     caps.MaxOutputSize = CSize(768, 576);
  148.     caps.OutputGranularityX = 16;
  149. caps.OutputGranularityY = 1;
  150.     caps.StretchTapsX = caps.StretchTapsY = 0;
  151.     caps.ShrinkTapsX = caps.ShrinkTapsY = 0;
  152.     caps.MinFrameInterval = 100000i64;
  153.     caps.MaxFrameInterval = 100000000i64;
  154.     caps.MinBitsPerSecond = caps.MaxBitsPerSecond = 0;
  155. }
  157. static void SetupDefaultCaps(AM_MEDIA_TYPE* pmt, AUDIO_STREAM_CONFIG_CAPS& caps)
  158. {
  159. memset(&caps, 0, sizeof(caps));
  161. if(!pmt) return;
  163. WAVEFORMATEX* wfe = (WAVEFORMATEX*)pmt->pbFormat;
  165.     caps.guid = GUID_NULL;
  166. caps.MinimumChannels = caps.MaximumChannels = wfe->nChannels;
  167.     caps.ChannelsGranularity = 1;
  168. caps.MinimumBitsPerSample = caps.MaximumBitsPerSample = wfe->wBitsPerSample;
  169.     caps.BitsPerSampleGranularity = 1;
  170. caps.MinimumSampleFrequency = caps.MaximumSampleFrequency = wfe->nSamplesPerSec;
  171.     caps.SampleFrequencyGranularity = 1;
  172. }
  174. template<class T>
  175. static void SetupMediaTypes(CComPtr<IAMStreamConfig> pAMSC, CFormatArray<T>& tfa, CComboBox& type, CComboBox& dim, CMediaType& mt)
  176. {
  177. tfa.RemoveAll();
  178. type.ResetContent();
  179. dim.ResetContent();
  180. type.EnableWindow(FALSE);
  181. dim.EnableWindow(FALSE);
  183. if(!pAMSC) return;
  185. AM_MEDIA_TYPE* pcurmt = NULL;
  186. pAMSC->GetFormat(&pcurmt);
  188. int iCount = 0, iSize;
  189. if(SUCCEEDED(pAMSC->GetNumberOfCapabilities(&iCount, &iSize))
  190. && iSize == sizeof(T) && iCount > 0)
  191. {
  192. for(int i = 0; i < iCount; i++)
  193. {
  194. T caps;
  195. AM_MEDIA_TYPE* pmt = NULL;
  196. if(SUCCEEDED(pAMSC->GetStreamCaps(i, &pmt, (BYTE*)&caps)))
  197. {
  198. tfa.AddFormat(pmt, caps);
  199. }
  200. }
  202. if(iSize == sizeof(VIDEO_STREAM_CONFIG_CAPS))
  203. {
  204. for(int i = 0, cnt = tfa.GetCount(); i < cnt; i++)
  205. {
  206. if(tfa[i]->GetCount() != 1) continue;
  208. CFormatElem<T>* pfe = tfa[i]->GetAt(0);
  210. if(pfe->mt.formattype != FORMAT_VideoInfo
  211. && pfe->mt.formattype != FORMAT_VideoInfo2)
  212. continue;
  214. static SIZE presets[] = 
  215. {
  216. {160, 120}, {192, 144},
  217. {320, 240}, {384, 288},
  218. {480, 240}, {512, 288},
  219. {480, 360}, {512, 384},
  220. {640, 240}, {768, 288},
  221. {640, 480}, {768, 576},
  222. {704, 240}, {704, 288},
  223. {704, 480}, {704, 576},
  224. {720, 240}, {720, 288},
  225. {720, 480}, {720, 576},
  226. {768, 240}, {768, 288},
  227. {768, 480}, {768, 576},
  228. };
  230. VIDEO_STREAM_CONFIG_CAPS* pcaps = (VIDEO_STREAM_CONFIG_CAPS*)&pfe->caps;
  231. BITMAPINFOHEADER bihCur;
  232. ExtractBIH(&pfe->mt, &bihCur);
  234. for(int j = 0; j < countof(presets); j++)
  235. {
  236. if(presets[j].cx == bihCur.biWidth
  237. && presets[j].cy == abs(bihCur.biHeight)
  238. || presets[j].cx < pcaps->MinOutputSize.cx
  239. || presets[j].cx > pcaps->MaxOutputSize.cx
  240. || presets[j].cy < pcaps->MinOutputSize.cy
  241. || presets[j].cy > pcaps->MaxOutputSize.cy
  242. || presets[j].cx % pcaps->OutputGranularityX
  243. || presets[j].cy % pcaps->OutputGranularityY)
  244. continue;
  246. CMediaType mt = pfe->mt;
  248. if(mt.formattype == FORMAT_VideoInfo)
  249. {
  250. VIDEOINFOHEADER* vih = (VIDEOINFOHEADER*)mt.pbFormat;
  251. if(!vih->bmiHeader.biHeight) vih->bmiHeader.biHeight = 1;
  252. vih->bmiHeader.biWidth = presets[j].cx;
  253. vih->bmiHeader.biHeight = presets[j].cy*(vih->bmiHeader.biHeight/vih->bmiHeader.biHeight);
  254. vih->bmiHeader.biSizeImage = presets[j].cx*presets[j].cy*vih->bmiHeader.biBitCount>>3;
  256. AM_MEDIA_TYPE* pmt = (AM_MEDIA_TYPE*)CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE));
  257. CopyMediaType(pmt, &mt);
  258. tfa.AddFormat(pmt, pcaps, sizeof(*pcaps));
  260. if(presets[j].cx*3 != presets[j].cy*4)
  261. {
  262. int extra = mt.cbFormat - sizeof(VIDEOINFOHEADER);
  263. int bmiHeaderSize = sizeof(vih->bmiHeader) + extra;
  264. BYTE* pbmiHeader = new BYTE[bmiHeaderSize];
  265. memcpy(pbmiHeader, &vih->bmiHeader, bmiHeaderSize);
  266. mt.ReallocFormatBuffer(FIELD_OFFSET(VIDEOINFOHEADER2, bmiHeader) + bmiHeaderSize);
  267. VIDEOINFOHEADER2* vih2 = (VIDEOINFOHEADER2*)mt.pbFormat;
  268. memcpy(&vih2->bmiHeader, pbmiHeader, bmiHeaderSize);
  269. delete [] pbmiHeader;
  270. vih2->dwInterlaceFlags = vih2->dwCopyProtectFlags = 0;
  271. vih2->dwReserved1 = vih2->dwReserved2 = 0;
  272. vih2->dwPictAspectRatioX = 4;
  273. vih2->dwPictAspectRatioY = 3;
  275. AM_MEDIA_TYPE* pmt = (AM_MEDIA_TYPE*)CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE));
  276. CopyMediaType(pmt, &mt);
  277. tfa.AddFormat(pmt, pcaps, sizeof(*pcaps));
  278. }
  279. }
  280. else if(mt.formattype == FORMAT_VideoInfo2)
  281. {
  282. VIDEOINFOHEADER2* vih2 = (VIDEOINFOHEADER2*)mt.pbFormat;
  283. if(!vih2->bmiHeader.biHeight) vih2->bmiHeader.biHeight = 1;
  284. vih2->bmiHeader.biWidth = presets[j].cx;
  285. vih2->bmiHeader.biHeight = presets[j].cy*(vih2->bmiHeader.biHeight/vih2->bmiHeader.biHeight);
  286. vih2->bmiHeader.biSizeImage = presets[j].cx*presets[j].cy*vih2->bmiHeader.biBitCount>>3;
  287. vih2->dwPictAspectRatioX = 4;
  288. vih2->dwPictAspectRatioY = 3;
  290. AM_MEDIA_TYPE* pmt = (AM_MEDIA_TYPE*)CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE));
  291. CopyMediaType(pmt, &mt);
  292. tfa.AddFormat(pmt, pcaps, sizeof(*pcaps));
  293. }
  294. }
  295. }
  296. }
  297. }
  299. if(tfa.GetCount() == 0)
  300. {
  301. if(pcurmt && (pcurmt->majortype == MEDIATYPE_Video || pcurmt->majortype == MEDIATYPE_Audio))
  302. {
  303. AM_MEDIA_TYPE* pmt = (AM_MEDIA_TYPE*)CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE));
  304. CopyMediaType(pmt, pcurmt);
  305. T caps;
  306. SetupDefaultCaps(pmt, caps);
  307.             tfa.AddFormat(pmt, caps);
  308. }
  309. else
  310. {
  311. mt.majortype = GUID_NULL;
  312. if(pcurmt) DeleteMediaType(pcurmt);
  313. return;
  314. }
  315. }
  317. for(int i = 0; i < (int)tfa.GetCount(); i++)
  318. {
  319. CFormat<T>* pf = tfa[i];
  320. int j = type.AddString(pf->name);
  321. type.SetItemData(j, (DWORD_PTR)pf);
  322. }
  324. CFormat<T>* pf = NULL;
  325. CFormatElem<T>* pfe = NULL;
  327. if(!pcurmt)
  328. {
  329. pf = tfa[0];
  330. pfe = pf->GetAt(0);
  331. }
  332. else if(!tfa.FindFormat(pcurmt, NULL, &pf, &pfe) && !tfa.FindFormat(pcurmt, &pf))
  333. {
  334. if(pcurmt) DeleteMediaType(pcurmt);
  335. return;
  336. }
  338. for(int i = 0; i < (int)pf->GetCount(); i++)
  339. {
  340. CFormatElem<T>* pfe = pf->GetAt(i);
  341. int j = dim.AddString(tfa.MakeDimensionName(pfe));
  342. dim.SetItemData(j, (DWORD_PTR)pfe);
  343. }
  345. int iType = type.SetCurSel(type.FindStringExact(0, pf->name));
  346. if(iType < 0 && type.GetCount()) type.SetCurSel(0);
  347. int iDim = dim.SetCurSel(dim.FindStringExact(0, tfa.MakeDimensionName(pfe)));
  348. // if(iDim < 0 && dim.GetCount()) dim.SetCurSel(iDim = 0);
  350. CorrectComboListWidth(type, type.GetParent()->GetFont());
  351. CorrectComboListWidth(dim, dim.GetParent()->GetFont());
  353. if(iDim >= 0) mt = ((CFormatElem<T>*)dim.GetItemData(iDim))->mt;
  354. else if(pcurmt) mt = *pcurmt;
  356. type.EnableWindow(type.GetCount() > 0);
  357. dim.EnableWindow(dim.GetCount() > 0);
  359. if(pcurmt) DeleteMediaType(pcurmt);
  360. }
  362. template<class T>
  363. static bool SetupDimension(CFormatArray<T>& tfa, CComboBox& type, CComboBox& dim)
  364. {
  365. CString str;
  366. dim.GetWindowText(str);
  368. dim.ResetContent();
  369. dim.EnableWindow(FALSE);
  371. int iSel = type.GetCurSel();
  372. if(iSel < 0) return(false);
  374. CFormat<T>* pf = (CFormat<T>*)type.GetItemData(iSel);
  376. for(int i = 0; i < (int)pf->GetCount(); i++)
  377. {
  378. CFormatElem<T>* pfe = pf->GetAt(i);
  379. dim.SetItemData(dim.AddString(tfa.MakeDimensionName(pfe)), (DWORD_PTR)pfe);
  380. }
  382. CorrectComboListWidth(dim, dim.GetParent()->GetFont());
  384. dim.SetCurSel(dim.FindStringExact(0, str));
  385. dim.EnableWindow(dim.GetCount() > 0);
  387. return(dim.GetCurSel() >= 0);
  388. }
  390. static void InitCodecList(CArray<Codec>& codecs, CComboBox& box, const GUID& cat)
  391. {
  392. codecs.RemoveAll();
  393. box.ResetContent();
  394. box.EnableWindow(FALSE);
  396. box.SetItemData(box.AddString(_T("Uncompressed")), (DWORD_PTR)-1);
  398. BeginEnumSysDev(cat, pMoniker)
  399. {
  400. Codec c;
  402. c.pMoniker = pMoniker;
  403. /*
  404. CComPtr<IBaseFilter> pBF;
  405. if(FAILED(pMoniker->BindToObject(0, 0, IID_IBaseFilter, (void**)&pBF)) || !pBF)
  406. continue;
  408. c.pBF = pBF;
  409. */
  410. LPOLESTR strName = NULL;
  411. if(FAILED(pMoniker->GetDisplayName(NULL, NULL, &strName)))
  412. continue;
  414. c.DisplayName = strName;
  415. CoTaskMemFree(strName);
  417. CComPtr<IPropertyBag> pPB;
  418. pMoniker->BindToStorage(0, 0, IID_IPropertyBag, (void**)&pPB);
  420. CComVariant var;
  421. if(FAILED(pPB->Read(CComBSTR(_T("FriendlyName")), &var, NULL)))
  422. continue;
  424. c.FriendlyName = var.bstrVal;
  426. CStringW str = CStringW(c.DisplayName).MakeLower();
  427. if(str.Find(L"@device:dmo:") == 0)
  428. c.FriendlyName = _T("(DMO) ") + c.FriendlyName;
  429. else if(str.Find(L"@device:sw:") == 0)
  430. c.FriendlyName = _T("(DS) ") + c.FriendlyName;
  431. else if(str.Find(L"@device:cm:") == 0)
  432. c.FriendlyName = _T("(VfW) ") + c.FriendlyName;
  434. box.SetItemData(
  435. box.AddString(c.FriendlyName),
  436. (DWORD_PTR)codecs.Add(c));
  437. }
  438. EndEnumSysDev
  440. box.EnableWindow(box.GetCount() > 1);
  442. CorrectComboListWidth(box, box.GetParent()->GetFont());
  444. LoadDefaultCodec(codecs, box, cat);
  445. }
  447. static int ShowPPage(CArray<Codec>& codecs, CComboBox& box, HWND hWnd = NULL)
  448. {
  449. int iSel = box.GetCurSel();
  450. if(iSel < 0) return(-1);
  452. iSel = box.GetItemData(iSel);
  453. if(iSel < 0) return(-1);
  455. Codec& c = codecs[iSel];
  457. if(!c.pBF)
  458. {
  459. c.pMoniker->BindToObject(NULL, NULL, __uuidof(IBaseFilter), (void**)&c.pBF);
  460. }
  462. if(CComQIPtr<ISpecifyPropertyPages> pSPP = c.pBF)
  463. {
  464. CAUUID caGUID;
  465. caGUID.pElems = NULL;
  466. if(SUCCEEDED(pSPP->GetPages(&caGUID)))
  467. {
  468. IUnknown* lpUnk = NULL;
  469. pSPP.QueryInterface(&lpUnk);
  470. OleCreatePropertyFrame(
  471. hWnd, 0, 0, CStringW(c.FriendlyName), 
  472. 1, (IUnknown**)&lpUnk, 
  473. caGUID.cElems, caGUID.pElems, 
  474. 0, 0, NULL);
  475. lpUnk->Release();
  477. if(caGUID.pElems) CoTaskMemFree(caGUID.pElems);
  478. }
  479. }
  480. else if(CComQIPtr<IAMVfwCompressDialogs> pAMVfWCD = c.pBF)
  481. {
  482. if(pAMVfWCD->ShowDialog(VfwCompressDialog_QueryConfig, NULL) == S_OK)
  483. pAMVfWCD->ShowDialog(VfwCompressDialog_Config, hWnd);
  484. }
  486. return(iSel);
  487. }
  489. // CPlayerCaptureDialog dialog
  491. IMPLEMENT_DYNAMIC(CPlayerCaptureDialog, CDialog)
  492. CPlayerCaptureDialog::CPlayerCaptureDialog()
  493. : CDialog(CPlayerCaptureDialog::IDD, NULL)
  494. , m_vidfps(0)
  495. , m_file(_T(""))
  496. , m_fVidOutput(TRUE)
  497. , m_fAudOutput(TRUE)
  498. , m_fVidPreview(FALSE)
  499. , m_fAudPreview(FALSE)
  500. , m_nVidBuffers(0)
  501. , m_nAudBuffers(0)
  502. , m_pVidBuffer(NULL)
  503. , m_pAudBuffer(NULL)
  504. , m_fSepAudio(FALSE)
  505. , m_muxtype(0)
  506. {
  507. }
  509. CPlayerCaptureDialog::~CPlayerCaptureDialog()
  510. {
  511. EmptyVideo();
  512. EmptyAudio();
  513. }
  515. BOOL CPlayerCaptureDialog::Create(CWnd* pParent)
  516. {
  517. if(!__super::Create(IDD, pParent))
  518. return FALSE;
  520. EmptyVideo();
  521. EmptyAudio();
  523. return TRUE;
  524. }
  526. void CPlayerCaptureDialog::DoDataExchange(CDataExchange* pDX)
  527. {
  528. __super::DoDataExchange(pDX);
  529. DDX_Control(pDX, IDC_COMBO4, m_vidinput);
  530. DDX_Control(pDX, IDC_COMBO1, m_vidtype);
  531. DDX_Control(pDX, IDC_COMBO5, m_viddimension);
  532. DDX_Control(pDX, IDC_SPIN1, m_vidhor);
  533. DDX_Control(pDX, IDC_SPIN2, m_vidver);
  534. DDX_Control(pDX, IDC_EDIT1, m_vidhoredit);
  535. DDX_Control(pDX, IDC_EDIT2, m_vidveredit);
  536. DDX_Control(pDX, IDC_EDIT3, m_vidfpsedit);
  537. DDX_Control(pDX, IDC_BUTTON1, m_vidsetres);
  538. DDX_Control(pDX, IDC_COMBO3, m_audinput);
  539. DDX_Control(pDX, IDC_COMBO2, m_audtype);
  540. DDX_Control(pDX, IDC_COMBO6, m_auddimension);
  541. DDX_Control(pDX, IDC_COMBO7, m_vidcodec);
  542. DDX_Control(pDX, IDC_COMBO9, m_vidcodectype);
  543. DDX_Control(pDX, IDC_COMBO10, m_vidcodecdimension);
  544. DDX_Check(pDX, IDC_CHECK2, m_fVidOutput);
  545. DDX_Control(pDX, IDC_CHECK2, m_vidoutput);
  546. DDX_Check(pDX, IDC_CHECK4, m_fVidPreview);
  547. DDX_Control(pDX, IDC_CHECK4, m_vidpreview);
  548. DDX_Control(pDX, IDC_COMBO8, m_audcodec);
  549. DDX_Control(pDX, IDC_COMBO12, m_audcodectype);
  550. DDX_Control(pDX, IDC_COMBO11, m_audcodecdimension);
  551. DDX_Check(pDX, IDC_CHECK3, m_fAudOutput);
  552. DDX_Control(pDX, IDC_CHECK3, m_audoutput);
  553. DDX_Check(pDX, IDC_CHECK5, m_fAudPreview);
  554. DDX_Control(pDX, IDC_CHECK5, m_audpreview);
  555. DDX_Text(pDX, IDC_EDIT4, m_file);
  556. DDX_Control(pDX, IDC_BUTTON2, m_recordbtn);
  557. DDX_Text(pDX, IDC_EDIT9, m_nVidBuffers);
  558. DDX_Text(pDX, IDC_EDIT12, m_nAudBuffers);
  559. DDX_Check(pDX, IDC_CHECK7, m_fSepAudio);
  560. DDX_CBIndex(pDX, IDC_COMBO14, m_muxtype);
  561. DDX_Control(pDX, IDC_COMBO14, m_muxctrl);
  562. }
  564. BOOL CPlayerCaptureDialog::PreTranslateMessage(MSG* pMsg)
  565. {
  566. if(pMsg->message == WM_KEYDOWN)
  567. {
  568. if(pMsg->wParam == VK_RETURN)
  569. {
  570. CWnd* pFocused = GetFocus();
  571. if(pFocused && pFocused->m_hWnd == m_vidfpsedit.m_hWnd)
  572. {
  573. UpdateGraph();
  574. }
  575. }
  576. }
  578. return __super::PreTranslateMessage(pMsg);
  579. }
  582. void CPlayerCaptureDialog::EmptyVideo()
  583. {
  584. // first save channel from previous session
  586. if(m_pAMTuner && !m_VidDisplayName.IsEmpty())
  587. {
  588. long lChannel = 0, lVivSub = 0, lAudSub = 0;
  589. m_pAMTuner->get_Channel(&lChannel, &lVivSub, &lAudSub);
  590. AfxGetApp()->WriteProfileInt(_T("Capture\") + CString(m_VidDisplayName), _T("Channel"), lChannel);
  591. }
  593. //
  595. m_vfa.RemoveAll();
  597. m_pAMXB = NULL;
  598. m_pAMTuner = NULL;
  599. m_pAMVSC = NULL;
  601. if(IsWindow(m_hWnd))
  602. {
  603. m_vidinput.ResetContent();
  604. m_vidinput.EnableWindow(FALSE);
  605. m_vidtype.ResetContent();
  606. m_vidtype.EnableWindow(FALSE);
  607. m_viddimension.ResetContent();
  608. m_viddimension.EnableWindow(FALSE);
  609. m_vidhor.EnableWindow(FALSE);
  610. m_vidver.EnableWindow(FALSE);
  611. m_vidhoredit.EnableWindow(FALSE);
  612. m_vidveredit.EnableWindow(FALSE);
  613. m_vidfpsedit.EnableWindow(FALSE);
  614. m_vidfps = 0;
  615. m_vidsetres.EnableWindow(FALSE);
  616. UpdateData(FALSE);
  617. }
  618. }
  620. void CPlayerCaptureDialog::EmptyAudio()
  621. {
  622. m_afa.RemoveAll();
  624. m_pAMASC = NULL;
  625. m_pAMAIM.RemoveAll();
  627. if(IsWindow(m_hWnd))
  628. {
  629. m_audinput.ResetContent();
  630. m_audinput.EnableWindow(FALSE);
  631. m_audtype.ResetContent();
  632. m_audtype.EnableWindow(FALSE);
  633. m_auddimension.ResetContent();
  634. m_auddimension.EnableWindow(FALSE);
  635. UpdateData(FALSE);
  636. }
  637. }
  639. void CPlayerCaptureDialog::UpdateMediaTypes()
  640. {
  641. UpdateData();
  643. // fps
  645. CString fps;
  646. m_vidfpsedit.GetWindowText(fps);
  647. if(!fps.IsEmpty())
  648. {
  649. float ffps;
  650. _stscanf(fps, _T("%f"), &ffps);
  651. if(ffps > 0) m_vidfps = ffps;
  652. }
  654. // video
  656. {
  657. AM_MEDIA_TYPE* pmt = NULL;
  658. VIDEO_STREAM_CONFIG_CAPS* pcaps = NULL;
  660. int i = m_viddimension.GetCurSel();
  661. if(i >= 0)
  662. {
  663. pmt = (AM_MEDIA_TYPE*)CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE));
  664. CopyMediaType(pmt, &((CVidFormatElem*)m_viddimension.GetItemData(i))->mt);
  665. pcaps = &((CVidFormatElem*)m_viddimension.GetItemData(i))->caps;
  666. }
  667. else if(m_pAMVSC)
  668. {
  669. m_pAMVSC->GetFormat(&pmt);
  670. }
  672. if(pmt)
  673. {
  674. if(m_vidfps > 0)
  675. {
  676. REFERENCE_TIME atpf = (REFERENCE_TIME)(10000000.0 / m_vidfps);
  678. if(pcaps)
  679. {
  680. // FIXME: some drivers do not set the interval right and they still accept the preferable but unfortunately out-of-range fps
  681. // atpf = min(max(atpf, pcaps->MinFrameInterval), pcaps->MaxFrameInterval);
  682. }
  684. if(pmt->formattype == FORMAT_VideoInfo)
  685. ((VIDEOINFOHEADER*)pmt->pbFormat)->AvgTimePerFrame = atpf;
  686. else if(pmt->formattype == FORMAT_VideoInfo2)
  687. ((VIDEOINFOHEADER2*)pmt->pbFormat)->AvgTimePerFrame = atpf;
  688. }
  690. BITMAPINFOHEADER* bih = (pmt->formattype == FORMAT_VideoInfo)
  691. ? &((VIDEOINFOHEADER*)pmt->pbFormat)->bmiHeader
  692. : (pmt->formattype == FORMAT_VideoInfo2)
  693. ? &((VIDEOINFOHEADER2*)pmt->pbFormat)->bmiHeader
  694. : NULL;
  696. bih->biWidth = m_vidhor.GetPos();
  697. bih->biHeight = m_vidver.GetPos();
  698. bih->biSizeImage = bih->biWidth*bih->biHeight*bih->biBitCount>>3;
  700. SaveMediaType(m_VidDisplayName, pmt);
  702. m_mtv = *pmt;
  703. DeleteMediaType(pmt);
  704. }
  705. }
  707. // audio
  709. {
  710. AM_MEDIA_TYPE* pmt = NULL;
  712. int i = m_auddimension.GetCurSel();
  713. if(i >= 0)
  714. {
  715. pmt = (AM_MEDIA_TYPE*)CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE));
  716. CopyMediaType(pmt, &((CAudFormatElem*)m_auddimension.GetItemData(i))->mt);
  717. }
  718. else if(m_pAMASC)
  719. {
  720. m_pAMASC->GetFormat(&pmt);
  721. }
  723. if(pmt)
  724. {
  725. SaveMediaType(m_AudDisplayName, pmt);
  727. m_mta = *pmt;  
  728. DeleteMediaType(pmt);
  729. }
  730. }
  731. }
  733. void CPlayerCaptureDialog::UpdateUserDefinableControls()
  734. {
  735. int iSel = m_viddimension.GetCurSel();
  736. if(iSel < 0) return;
  738. CVidFormatElem* pvfe = (CVidFormatElem*)m_viddimension.GetItemData(iSel);
  739. if(!pvfe) return;
  741. if(!m_pAMVSC) return;
  743. AM_MEDIA_TYPE* pmt = NULL;
  744. m_pAMVSC->GetFormat(&pmt);
  745. if(!pmt) return;
  747. BITMAPINFOHEADER* bih = (pmt->formattype == FORMAT_VideoInfo)
  748. ? &((VIDEOINFOHEADER*)pmt->pbFormat)->bmiHeader
  749. : (pmt->formattype == FORMAT_VideoInfo2)
  750. ? &((VIDEOINFOHEADER2*)pmt->pbFormat)->bmiHeader
  751. : NULL;
  753. if(!bih) return;
  755. UDACCEL ua[3] = {{0,0},{2,0},{4,0}};
  757. int w = m_vidhor.GetPos(), h = m_vidver.GetPos();
  759. m_vidhor.SetRange((short)pvfe->caps.MinOutputSize.cx, (short)pvfe->caps.MaxOutputSize.cx);
  760. /* if(bih->biCompression == mmioFOURCC('Y','U','Y','2')) // FIXME: bt8x8 drivers seem to crop the right side in yuv2 mode if the width is not divisable by 64
  761. pvfe->caps.OutputGranularityX = 64;
  762. */
  763. ua[0].nInc = pvfe->caps.OutputGranularityX;
  764. ua[1].nInc = pvfe->caps.OutputGranularityX*2;
  765. ua[2].nInc = pvfe->caps.OutputGranularityX*4;
  766. m_vidhor.SetAccel(3, ua);
  768. m_vidver.SetRange((short)pvfe->caps.MinOutputSize.cy, (short)pvfe->caps.MaxOutputSize.cy);
  769. ua[0].nInc = pvfe->caps.OutputGranularityY;
  770. ua[1].nInc = pvfe->caps.OutputGranularityY*2;
  771. ua[2].nInc = pvfe->caps.OutputGranularityY*4;
  772. m_vidver.SetAccel(3, ua);
  774. m_vidhor.SetPos(bih->biWidth);
  775. m_vidver.SetPos(abs(bih->biHeight));
  777. CString fps;
  778. fps.Format(_T("%.4f"), (float)(10000000.0 / ((VIDEOINFOHEADER*)pmt->pbFormat)->AvgTimePerFrame));
  779. m_vidfpsedit.SetWindowText(fps);
  781. DeleteMediaType(pmt);
  782. }
  784. void CPlayerCaptureDialog::UpdateVideoCodec()
  785. {
  786. int iSel = m_vidcodec.GetCurSel();
  787. if(iSel >= 0) iSel = m_vidcodec.GetItemData(iSel);
  789. m_pVidEnc = iSel < 0 ? NULL : m_pVidEncArray[iSel].pBF;
  790. m_pVidEncMoniker = iSel < 0 ? NULL : m_pVidEncArray[iSel].pMoniker;
  792. // CString DisplayName = iSel < 0 ? _T("") : CString(m_pVidEncArray[iSel].DisplayName.m_str);
  793. CComQIPtr<IAMStreamConfig> pAMSC = GetFirstPin(m_pVidEnc, PINDIR_OUTPUT);
  795. SetupMediaTypes(pAMSC, m_vcfa, m_vidcodectype, m_vidcodecdimension, m_mtcv);
  797. SaveDefaultCodec(m_pVidEncArray, m_vidcodec, CLSID_VideoCompressorCategory);
  799. // SaveMediaType(DisplayName, &m_mtcv);
  800. }
  802. void CPlayerCaptureDialog::UpdateAudioCodec()
  803. {
  804. int iSel = m_audcodec.GetCurSel();
  805. if(iSel >= 0) iSel = m_audcodec.GetItemData(iSel);
  807. m_pAudEnc = iSel < 0 ? NULL : m_pAudEncArray[iSel].pBF;
  808. m_pAudEncMoniker = iSel < 0 ? NULL : m_pAudEncArray[iSel].pMoniker;
  810. // CString DisplayName = iSel < 0 ? _T("") : CString(m_pAudEncArray[iSel].DisplayName.m_str);
  811. CComQIPtr<IAMStreamConfig> pAMSC = GetFirstPin(m_pAudEnc, PINDIR_OUTPUT); 
  813. SetupMediaTypes(pAMSC, m_acfa, m_audcodectype, m_audcodecdimension, m_mtca);
  815. SaveDefaultCodec(m_pAudEncArray, m_audcodec, CLSID_AudioCompressorCategory);
  817. // SaveMediaType(DisplayName, &m_mtca);
  818. }
  820. void CPlayerCaptureDialog::UpdateMuxer()
  821. {
  822. m_pMux = NULL;
  823. m_pAudMux = NULL;
  825. UpdateData();
  827. HRESULT hr;
  829. if(m_muxtype == 0) m_pMux.CoCreateInstance(CLSID_AviDest);
  830. else if(m_muxtype == 1) m_pMux.CoCreateInstance(CLSID_OggMux);
  831. else if(m_muxtype == 2) m_pMux = new CMatroskaMuxerFilter(NULL, &hr);
  832. else if(m_muxtype == 3) m_pMux = new CDSMMuxerFilter(NULL, &hr);
  833. else return;
  835. if(m_fSepAudio) m_pAudMux = new CWavDestFilter(NULL, &hr);
  836. }
  838. void CPlayerCaptureDialog::UpdateOutputControls()
  839. {
  840. UpdateData();
  842. m_recordbtn.EnableWindow(!m_file.IsEmpty() && (m_pAMVSC && m_fVidOutput || m_pAMASC && m_fAudOutput));
  843. m_vidcodec.EnableWindow(TRUE);
  844. m_audcodec.EnableWindow(TRUE);
  845. }
  847. void CPlayerCaptureDialog::UpdateGraph()
  848. {
  849. UpdateMediaTypes();
  851. // UpdateMuxer();
  853. ((CMainFrame*)AfxGetMainWnd())->BuildGraphVideoAudio(!!m_fVidPreview, false, !!m_fAudPreview, false);
  855. UpdateUserDefinableControls();
  856. }
  858. void CPlayerCaptureDialog::EnableControls(CWnd* pWnd, bool fEnable)
  859. {
  860. if(fEnable)
  861. {
  862. for(CWnd* pChild = pWnd->GetWindow(GW_CHILD); pChild; pChild = pChild->GetNextWindow())
  863. {
  864. BOOL fEnabled;
  865. if(m_wndenabledmap.Lookup(pChild->m_hWnd, fEnabled))
  866. pChild->EnableWindow(fEnabled);
  867. EnableControls(pChild, fEnable);
  868. }
  870. if(pWnd->m_hWnd == m_hWnd) 
  871. m_wndenabledmap.RemoveAll();
  873. m_recordbtn.SetWindowText(_T("Record"));
  874. }
  875. else
  876. {
  877. if(pWnd->m_hWnd == m_hWnd)
  878. m_wndenabledmap.RemoveAll();
  880. for(CWnd* pChild = pWnd->GetWindow(GW_CHILD); pChild; pChild = pChild->GetNextWindow())
  881. {
  882. m_wndenabledmap[pChild->m_hWnd] = pChild->IsWindowEnabled();
  883. pChild->EnableWindow(FALSE);
  884. EnableControls(pChild, fEnable);
  885. }
  887. m_recordbtn.EnableWindow(TRUE);
  888. m_recordbtn.SetWindowText(_T("Stop"));
  889. }
  890. }
  892. void CPlayerCaptureDialog::SetupVideoControls(
  893. CStringW DisplayName, 
  894. CComPtr<IAMStreamConfig> pAMSC, CComPtr<IAMCrossbar> pAMXB, CComPtr<IAMTVTuner> pAMTuner)
  895. {
  896. EmptyVideo();
  898. // crossbar
  900. if(m_pAMXB = pAMXB)
  901. {
  902. long OutputPinCount, InputPinCount;
  903. if(SUCCEEDED(pAMXB->get_PinCounts(&OutputPinCount, &InputPinCount)))
  904. {
  905. for(int i = 0; i < InputPinCount; i++)
  906. {
  907. long PinIndexRelated, PhysicalType;
  908. if(FAILED(pAMXB->get_CrossbarPinInfo(TRUE, i, &PinIndexRelated, &PhysicalType)))
  909. continue;
  911. if(PhysicalType >= PhysConn_Audio_Tuner)
  912. continue;
  914. CString str;
  915. switch(PhysicalType)
  916. {
  917. case PhysConn_Video_Tuner: str = _T("Tuner"); break;
  918. case PhysConn_Video_Composite: str = _T("Composite"); break;
  919. case PhysConn_Video_SVideo: str = _T("SVideo"); break;
  920. case PhysConn_Video_RGB: str = _T("RGB"); break;
  921. case PhysConn_Video_YRYBY: str = _T("YRYBY"); break;
  922. case PhysConn_Video_SerialDigital: str = _T("SerialDigital"); break;
  923. case PhysConn_Video_ParallelDigital: str = _T("ParallelDigital"); break;
  924. case PhysConn_Video_SCSI: str = _T("SCSI"); break;
  925. case PhysConn_Video_AUX: str = _T("AUX"); break;
  926. case PhysConn_Video_1394: str = _T("1394"); break;
  927. case PhysConn_Video_USB: str = _T("USB"); break;
  928. case PhysConn_Video_VideoDecoder: str = _T("VideoDecoder"); break;
  929. case PhysConn_Video_VideoEncoder: str = _T("VideoEncoder"); break;
  930. case PhysConn_Video_SCART: str = _T("SCART"); break;
  931. default: str.Format(_T("PhysicalType %d"), PhysicalType); break;
  932. }
  934. m_vidinput.SetItemData(m_vidinput.AddString(str), i);
  935. }
  936. }
  937. }
  939. if(m_vidinput.GetCount() > 0)
  940. {
  941. m_vidinput.EnableWindow(TRUE);
  943. long OutputPinCount, InputPinCount;
  944. if(SUCCEEDED(pAMXB->get_PinCounts(&OutputPinCount, &InputPinCount)))
  945. {
  946. for(int i = 0; i < OutputPinCount; i++)
  947. {
  948. long InputPinIndex;
  949. if(S_OK == pAMXB->get_IsRoutedTo(i, &InputPinIndex))
  950. {
  951. for(int j = 0; j < m_vidinput.GetCount(); j++)
  952. {
  953. if(m_vidinput.GetItemData(j) == InputPinIndex)
  954. {
  955. m_vidinput.SetCurSel(j);
  956. i = OutputPinCount;
  957. break;
  958. }
  959. }
  960. }
  961. }
  962. }
  963. }
  965. // tuner
  967. if(m_pAMTuner = pAMTuner)
  968. {
  969. // TODO:...
  970. }
  972. // streamconfig
  974. if(m_pAMVSC = pAMSC)
  975. {
  976. m_VidDisplayName = DisplayName;
  978. AM_MEDIA_TYPE* pmt;
  979. if(LoadMediaType(DisplayName, &pmt))
  980. {
  981. pAMSC->SetFormat(pmt);
  982. DeleteMediaType(pmt);
  983. }
  985. SetupMediaTypes(pAMSC, m_vfa, m_vidtype, m_viddimension, m_mtv);
  986. }
  988. if(m_vidtype.GetCount() > 0)
  989. {
  990. m_vidfpsedit.EnableWindow(TRUE);
  991. m_vidhor.EnableWindow(TRUE);
  992. m_vidver.EnableWindow(TRUE);
  993. m_vidhoredit.EnableWindow(TRUE);
  994. m_vidveredit.EnableWindow(TRUE);
  995. m_vidsetres.EnableWindow(TRUE);
  996. }
  998. {
  999. m_vidoutput.EnableWindow(TRUE);
  1000. m_vidpreview.EnableWindow(TRUE);
  1001. }
  1003. UpdateMediaTypes();
  1005. UpdateUserDefinableControls();
  1007. UpdateOutputControls();
  1008. }
  1010. void CPlayerCaptureDialog::SetupVideoControls(
  1011. CStringW DisplayName, 
  1012. CComPtr<IAMStreamConfig> pAMSC, CComPtr<IAMVfwCaptureDialogs> pAMVfwCD)
  1013. {
  1014. EmptyVideo();
  1016. if(m_pAMVfwCD = pAMVfwCD)
  1017. {
  1018. if(S_OK == m_pAMVfwCD->HasDialog(VfwCaptureDialog_Source))
  1019. m_vidinput.SetItemData(m_vidinput.AddString(_T("Source")), (DWORD_PTR)VfwCaptureDialog_Source);
  1020. if(S_OK == m_pAMVfwCD->HasDialog(VfwCaptureDialog_Format))
  1021. m_vidinput.SetItemData(m_vidinput.AddString(_T("Format")), (DWORD_PTR)VfwCaptureDialog_Format);
  1022. if(S_OK == m_pAMVfwCD->HasDialog(VfwCaptureDialog_Display))
  1023. m_vidinput.SetItemData(m_vidinput.AddString(_T("Display")), (DWORD_PTR)VfwCaptureDialog_Display);
  1025. if(m_vidinput.GetCount() > 0)
  1026. {
  1027. m_vidinput.EnableWindow(TRUE);
  1028. m_vidinput.SetCurSel(0);
  1029. }
  1030. }
  1032. // streamconfig
  1034. if(m_pAMVSC = pAMSC)
  1035. {
  1036. m_VidDisplayName = DisplayName;
  1038. AM_MEDIA_TYPE* pmt;
  1039. if(LoadMediaType(DisplayName, &pmt))
  1040. {
  1041. pAMSC->SetFormat(pmt);
  1042. DeleteMediaType(pmt);
  1043. }
  1045. SetupMediaTypes(pAMSC, m_vfa, m_vidtype, m_viddimension, m_mtv);
  1046. }
  1048. if(m_vidtype.GetCount() > 0)
  1049. {
  1050. m_vidfpsedit.EnableWindow(TRUE);
  1051. m_vidhor.EnableWindow(TRUE);
  1052. m_vidver.EnableWindow(TRUE);
  1053. m_vidhoredit.EnableWindow(TRUE);
  1054. m_vidveredit.EnableWindow(TRUE);
  1055. m_vidsetres.EnableWindow(TRUE);
  1056. }
  1058. {
  1059. m_vidoutput.EnableWindow(TRUE);
  1060. m_vidpreview.EnableWindow(TRUE);
  1061. }
  1063. UpdateMediaTypes();
  1065. UpdateUserDefinableControls();
  1067. UpdateOutputControls();
  1068. }
  1070. void CPlayerCaptureDialog::SetupAudioControls(
  1071. CStringW DisplayName, 
  1072. CComPtr<IAMStreamConfig> pAMSC, CInterfaceArray<IAMAudioInputMixer>& pAMAIM)
  1073. {
  1074. EmptyAudio();
  1076. // input selection
  1078. if(pAMAIM.GetCount() > 0)
  1079. {
  1080. m_pAMAIM.Copy(pAMAIM);
  1082. int iSel = -1;
  1084. for(int i = 0; i < (int)m_pAMAIM.GetCount(); i++)
  1085. {
  1086. CComQIPtr<IPin> pPin = m_pAMAIM[i];
  1087. m_audinput.SetItemData(m_audinput.AddString(CString(GetPinName(pPin))), (DWORD_PTR)i);
  1089. BOOL fEnable;
  1090. if(SUCCEEDED(m_pAMAIM[i]->get_Enable(&fEnable)) && fEnable)
  1091. iSel = i;
  1092. }
  1094. if(m_audinput.GetCount() > 0)
  1095. {
  1096. for(int i = 0; i < m_audinput.GetCount(); i++)
  1097. {
  1098. if(m_audinput.GetItemData(i) == iSel)
  1099. {
  1100. m_audinput.SetCurSel(i);
  1101. break;
  1102. }
  1103. }
  1105. m_audinput.EnableWindow(TRUE);
  1106. }
  1107. }
  1109. // stream config
  1111. if(m_pAMASC = pAMSC)
  1112. {
  1113. m_AudDisplayName = DisplayName;
  1115. AM_MEDIA_TYPE* pmt;
  1116. if(LoadMediaType(DisplayName, &pmt))
  1117. {
  1118. pAMSC->SetFormat(pmt);
  1119. DeleteMediaType(pmt);
  1120. }
  1122. SetupMediaTypes(pAMSC, m_afa, m_audtype, m_auddimension, m_mta);
  1123. }
  1125. // if(m_audtype.GetCount() > 0)
  1126. {
  1127. m_audoutput.EnableWindow(TRUE);
  1128. m_audpreview.EnableWindow(TRUE);
  1129. }
  1131. UpdateMediaTypes();
  1133. UpdateUserDefinableControls();
  1135. UpdateOutputControls();
  1136. }
  1138. bool CPlayerCaptureDialog::IsTunerActive()
  1139. {
  1140. int iSel = m_vidinput.GetCurSel();
  1141. if(iSel < 0) return(false);
  1142. iSel = m_vidinput.GetItemData(iSel);
  1143. if(iSel < 0) return(false);
  1145. long PinIndexRelated, PhysicalType;
  1146. return(m_pAMXB
  1147. && SUCCEEDED(m_pAMXB->get_CrossbarPinInfo(TRUE, iSel, &PinIndexRelated, &PhysicalType))
  1148. && PhysicalType == PhysConn_Video_Tuner);
  1149. }
  1151. bool CPlayerCaptureDialog::SetVideoInput(int input)
  1152. {
  1153. if(!m_pAMXB || input < 0) return false;
  1155. for(int i = 0; i < m_vidinput.GetCount(); i++)
  1156. {
  1157. if(m_vidinput.GetItemData(i) == input)
  1158. {
  1159. m_vidinput.SetCurSel(i);
  1160. OnVideoInput();
  1161. return true;
  1162. }
  1163. }
  1165. return false;
  1166. }
  1168. bool CPlayerCaptureDialog::SetVideoChannel(int channel)
  1169. {
  1170. if(!m_pAMTuner || channel < 0) return false;
  1172. return SUCCEEDED(m_pAMTuner->put_Channel(channel, AMTUNER_SUBCHAN_DEFAULT, AMTUNER_SUBCHAN_DEFAULT));
  1173. }
  1175. bool CPlayerCaptureDialog::SetAudioInput(int input)
  1176. {
  1177. if(input < 0) return false;
  1179. for(int i = 0; i < m_audinput.GetCount(); i++)
  1180. {
  1181. if(m_audinput.GetItemData(i) == input)
  1182. {
  1183. m_audinput.SetCurSel(i);
  1184. OnAudioInput();
  1185. return true;
  1186. }
  1187. }
  1189. return false;
  1190. }
  1192. int CPlayerCaptureDialog::GetVideoInput()
  1193. {
  1194. int i = m_vidinput.GetCurSel();
  1195. if(i < 0) return -1;
  1196. return m_vidinput.GetItemData(i);
  1197. }
  1199. int CPlayerCaptureDialog::GetVideoChannel()
  1200. {
  1201. long lChannel, lVivSub, lAudSub;
  1202. return m_pAMTuner && SUCCEEDED(m_pAMTuner->get_Channel(&lChannel, &lVivSub, &lAudSub)) ? lChannel : -1;
  1203. }
  1205. int CPlayerCaptureDialog::GetAudioInput()
  1206. {
  1207. int i = m_audinput.GetCurSel();
  1208. if(i < 0) return -1;
  1209. return m_audinput.GetItemData(i);
  1210. }
  1212. BEGIN_MESSAGE_MAP(CPlayerCaptureDialog, CDialog)
  1213. ON_WM_DESTROY()
  1214. ON_CBN_SELCHANGE(IDC_COMBO4, OnVideoInput)
  1215. ON_CBN_SELCHANGE(IDC_COMBO1, OnVideoType)
  1216. ON_CBN_SELCHANGE(IDC_COMBO5, OnVideoDimension)
  1217. ON_BN_CLICKED(IDC_BUTTON1, OnOverrideVideoDimension)
  1218. ON_CBN_SELCHANGE(IDC_COMBO3, OnAudioInput)
  1219. ON_CBN_SELCHANGE(IDC_COMBO2, OnAudioType)
  1220. ON_CBN_SELCHANGE(IDC_COMBO6, OnAudioDimension)
  1221. ON_BN_CLICKED(IDC_CHECK2, OnRecordVideo)
  1222. ON_CBN_SELCHANGE(IDC_COMBO7, OnVideoCodec)
  1223. ON_CBN_SELCHANGE(IDC_COMBO9, OnVideoCodecType)
  1224. ON_CBN_SELCHANGE(IDC_COMBO10, OnVideoCodecDimension)
  1225. ON_BN_CLICKED(IDC_CHECK3, OnRecordAudio)
  1226. ON_CBN_SELCHANGE(IDC_COMBO8, OnAudioCodec)
  1227. ON_CBN_SELCHANGE(IDC_COMBO12, OnAudioCodecType)
  1228. ON_CBN_SELCHANGE(IDC_COMBO11, OnAudioCodecDimension)
  1229. ON_BN_CLICKED(IDC_BUTTON3, OnOpenFile)
  1230. ON_BN_CLICKED(IDC_BUTTON2, OnRecord)
  1231. ON_EN_CHANGE(IDC_EDIT9, OnEnChangeEdit9)
  1232. ON_EN_CHANGE(IDC_EDIT12, OnEnChangeEdit12)
  1233. ON_WM_TIMER()
  1234. ON_BN_CLICKED(IDC_CHECK4, OnBnClickedVidAudPreview)
  1235. ON_BN_CLICKED(IDC_CHECK5, OnBnClickedVidAudPreview)
  1236. ON_BN_CLICKED(IDC_CHECK7, OnBnClickedCheck7)
  1237. ON_CBN_SELCHANGE(IDC_COMBO14, OnCbnSelchangeCombo14)
  1238. END_MESSAGE_MAP()
  1241. // CPlayerCaptureDialog message handlers
  1243. BOOL CPlayerCaptureDialog::OnInitDialog()
  1244. {
  1245. __super::OnInitDialog();
  1247. InitCodecList(m_pVidEncArray, m_vidcodec, CLSID_VideoCompressorCategory);
  1248. UpdateVideoCodec();
  1250. InitCodecList(m_pAudEncArray, m_audcodec, CLSID_AudioCompressorCategory);
  1251. UpdateAudioCodec();
  1253. m_fEnableOgm = IsCLSIDRegistered(_T("{8cae96b7-85b1-4605-b23c-17ff5262b296}"));
  1255. m_nVidBuffers = AfxGetApp()->GetProfileInt(_T("Capture"), _T("VidBuffers"), 50);
  1256. m_nAudBuffers = AfxGetApp()->GetProfileInt(_T("Capture"), _T("AudBuffers"), 50);
  1257. m_fVidOutput = !!AfxGetApp()->GetProfileInt(_T("Capture"), _T("VidOutput"), TRUE);
  1258. m_fAudOutput = !!AfxGetApp()->GetProfileInt(_T("Capture"), _T("AudOutput"), TRUE);
  1259. m_fVidPreview = !!AfxGetApp()->GetProfileInt(_T("Capture"), _T("VidPreview"), TRUE);
  1260. m_fAudPreview = !!AfxGetApp()->GetProfileInt(_T("Capture"), _T("AudPreview"), TRUE);
  1261. m_muxtype = AfxGetApp()->GetProfileInt(_T("Capture"), _T("FileFormat"), 0);
  1262. m_file = AfxGetApp()->GetProfileString(_T("Capture"), _T("FileName"), _T(""));
  1263. m_fSepAudio = AfxGetApp()->GetProfileInt(_T("Capture"), _T("SepAudio"), TRUE);
  1265. m_muxctrl.AddString(_T("AVI"));
  1266. m_muxctrl.AddString(_T("Ogg Media"));
  1267. m_muxctrl.AddString(_T("Matroska"));
  1268. m_muxctrl.AddString(_T("DirectShow Media"));
  1270. // UpdateMuxer();
  1272. UpdateData(FALSE);
  1274. OnCbnSelchangeCombo14();
  1276. return TRUE;  // return TRUE unless you set the focus to a control
  1277. // EXCEPTION: OCX Property Pages should return FALSE
  1278. }
  1280. void CPlayerCaptureDialog::OnDestroy()
  1281. {
  1282. UpdateData();
  1284. AfxGetApp()->WriteProfileInt(_T("Capture"), _T("VidOutput"), m_fVidOutput);
  1285. AfxGetApp()->WriteProfileInt(_T("Capture"), _T("AudOutput"), m_fAudOutput);
  1286. AfxGetApp()->WriteProfileInt(_T("Capture"), _T("VidPreview"), m_fVidPreview);
  1287. AfxGetApp()->WriteProfileInt(_T("Capture"), _T("AudPreview"), m_fAudPreview);
  1288. AfxGetApp()->WriteProfileInt(_T("Capture"), _T("FileFormat"), m_muxtype);
  1289. AfxGetApp()->WriteProfileString(_T("Capture"), _T("FileName"), m_file);
  1290. AfxGetApp()->WriteProfileInt(_T("Capture"), _T("SepAudio"), m_fSepAudio);
  1292. __super::OnDestroy();
  1293. }
  1295. void CPlayerCaptureDialog::OnVideoInput()
  1296. {
  1297. int iSel = m_vidinput.GetCurSel();
  1298. if(iSel < 0) return;
  1299. iSel = m_vidinput.GetItemData(iSel);
  1300. if(iSel < 0) return;
  1302. if(m_pAMXB)
  1303. {
  1304. long PinIndexRelated, PhysicalType;
  1305. if(FAILED(m_pAMXB->get_CrossbarPinInfo(TRUE, iSel, &PinIndexRelated, &PhysicalType)))
  1306. return;
  1308. long OutputPinCount, InputPinCount;
  1309. if(FAILED(m_pAMXB->get_PinCounts(&OutputPinCount, &InputPinCount)))
  1310. return;
  1312. for(int i = 0; i < OutputPinCount; i++)
  1313. {
  1314. if(S_OK == m_pAMXB->CanRoute(i, iSel))
  1315. {
  1316. m_pAMXB->Route(i, iSel);
  1317. break;
  1318. }
  1319. }
  1321. if(PinIndexRelated >= 0)
  1322. {
  1323. for(int i = 0; i < OutputPinCount; i++)
  1324. {
  1325. if(S_OK == m_pAMXB->CanRoute(i, PinIndexRelated))
  1326. {
  1327. m_pAMXB->Route(i, PinIndexRelated);
  1328. break;
  1329. }
  1330. }
  1331. }
  1332. }
  1333. else if(m_pAMVfwCD)
  1334. {
  1335. if(S_OK == m_pAMVfwCD->HasDialog(iSel))
  1336. {
  1337. HRESULT hr = m_pAMVfwCD->ShowDialog(iSel, m_hWnd);
  1339. if(VFW_E_NOT_STOPPED == hr)
  1340. {
  1341. ((CMainFrame*)AfxGetMainWnd())->SendMessage(WM_COMMAND, ID_PLAY_STOP);
  1342. hr = m_pAMVfwCD->ShowDialog(iSel, m_hWnd);
  1343. ((CMainFrame*)AfxGetMainWnd())->SendMessage(WM_COMMAND, ID_PLAY_PLAY);
  1344. }
  1346. if(VFW_E_CANNOT_CONNECT == hr)
  1347. UpdateGraph();
  1348. }
  1349. }
  1350. }
  1352. void CPlayerCaptureDialog::OnVideoType()
  1353. {
  1354. if(SetupDimension(m_vfa, m_vidtype, m_viddimension))
  1355. OnVideoDimension();
  1356. }
  1358. void CPlayerCaptureDialog::OnVideoDimension()
  1359. {
  1360. int iSel = m_viddimension.GetCurSel();
  1361. if(iSel < 0) return;
  1363. CVidFormatElem* pvfe = (CVidFormatElem*)m_viddimension.GetItemData(iSel);
  1364. if(!pvfe) return;
  1366. BITMAPINFOHEADER* bih = (pvfe->mt.formattype == FORMAT_VideoInfo)
  1367. ? &((VIDEOINFOHEADER*)pvfe->mt.pbFormat)->bmiHeader
  1368. : (pvfe->mt.formattype == FORMAT_VideoInfo2)
  1369. ? &((VIDEOINFOHEADER2*)pvfe->mt.pbFormat)->bmiHeader
  1370. : NULL;
  1372. m_vidhor.SetRange(0, 32767);
  1373. m_vidver.SetRange(0, 32767);
  1374. m_vidhor.SetPos(bih->biWidth);
  1375. m_vidver.SetPos(abs(bih->biHeight));
  1376. CString fps;
  1377. fps.Format(_T("%.4f"), (float)(10000000.0 / ((VIDEOINFOHEADER*)pvfe->mt.pbFormat)->AvgTimePerFrame));
  1378. m_vidfpsedit.SetWindowText(fps);
  1380. UpdateGraph();
  1381. }
  1383. void CPlayerCaptureDialog::OnOverrideVideoDimension()
  1384. {
  1385. UpdateGraph();
  1386. }
  1388. void CPlayerCaptureDialog::OnAudioInput()
  1389. {
  1390. int iSel = m_audinput.GetCurSel();
  1392. for(int i = 0; i < (int)m_pAMAIM.GetCount(); i++)
  1393. {
  1394. m_pAMAIM[m_audinput.GetItemData(i)]->put_Enable(i == iSel ? TRUE : FALSE);
  1395. }
  1396. }
  1398. void CPlayerCaptureDialog::OnAudioType()
  1399. {
  1400. if(SetupDimension(m_afa, m_audtype, m_auddimension))
  1401. OnAudioDimension();
  1402. }
  1404. void CPlayerCaptureDialog::OnAudioDimension()
  1405. {
  1406. UpdateGraph();
  1407. }
  1409. void CPlayerCaptureDialog::OnRecordVideo()
  1410. {
  1411. UpdateOutputControls();
  1412. }
  1414. void CPlayerCaptureDialog::OnVideoCodec()
  1415. {
  1416. ShowPPage(m_pVidEncArray, m_vidcodec, m_hWnd);
  1417. UpdateVideoCodec();
  1418. }
  1420. void CPlayerCaptureDialog::OnVideoCodecType()
  1421. {
  1422. if(SetupDimension(m_vcfa, m_vidcodectype, m_vidcodecdimension))
  1423. OnVideoCodecDimension();
  1424. }
  1426. void CPlayerCaptureDialog::OnVideoCodecDimension()
  1427. {
  1428. int i = m_vidcodecdimension.GetCurSel();
  1429. if(i >= 0)
  1430. {
  1431. m_mtcv = ((CVidFormatElem*)m_vidcodecdimension.GetItemData(i))->mt;
  1433. // we have to recreate the encoder, otherwise it will accept the new media type for only the first time
  1434. m_pVidEnc = NULL;
  1435. m_pVidEncMoniker->BindToObject(0, 0, IID_IBaseFilter, (void**)&m_pVidEnc);
  1436. }
  1437. }
  1439. void CPlayerCaptureDialog::OnRecordAudio()
  1440. {
  1441. UpdateOutputControls();
  1442. }
  1444. void CPlayerCaptureDialog::OnAudioCodec()
  1445. {
  1446. ShowPPage(m_pAudEncArray, m_audcodec, m_hWnd);
  1447. UpdateAudioCodec();
  1448. }
  1450. void CPlayerCaptureDialog::OnAudioCodecType()
  1451. {
  1452. if(SetupDimension(m_acfa, m_audcodectype, m_audcodecdimension))
  1453. OnAudioCodecDimension();
  1454. }
  1456. void CPlayerCaptureDialog::OnAudioCodecDimension()
  1457. {
  1458. int i = m_audcodecdimension.GetCurSel();
  1459. if(i >= 0)
  1460. {
  1461. m_mtca = ((CAudFormatElem*)m_audcodecdimension.GetItemData(i))->mt;
  1463. // we have to recreate the encoder, otherwise it will accept the new media type for only the first time
  1464. m_pAudEnc = NULL;
  1465. m_pAudEncMoniker->BindToObject(0, 0, IID_IBaseFilter, (void**)&m_pAudEnc);
  1466. /*
  1467. SaveMediaType(
  1468. CString(m_pAudEncArray[m_audcodec.GetItemData(m_audcodec.GetCurSel())].DisplayName.m_str), 
  1469. &m_mtca);
  1470. */ }
  1471. }
  1473. void CPlayerCaptureDialog::OnOpenFile()
  1474. {
  1475. CFileDialog fd(FALSE, NULL, NULL, 
  1476. OFN_EXPLORER|OFN_ENABLESIZING|OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT, 
  1477. _T("Media files (*.avi,*.ogm,*.mkv,*.dsm)|*.avi;*.ogm;*.mkv;*.dsm|"), this, 0);
  1479. if(fd.DoModal() == IDOK)
  1480. {
  1481. CString str = fd.GetPathName();
  1483. CString ext = str.Mid(str.ReverseFind('.')+1).MakeLower();
  1484. if(ext == _T("avi")) m_muxtype = 0;
  1485. else if(ext == _T("ogm")) m_muxtype = 1;
  1486. else if(ext == _T("mkv")) m_muxtype = 2;
  1487. else if(ext == _T("dsm")) m_muxtype = 3;
  1488. else
  1489. {
  1490. if(m_muxtype == 0) str += _T(".avi");
  1491. else if(m_muxtype == 1) str += _T(".ogm");
  1492. else if(m_muxtype == 2) str += _T(".mkv");
  1493. else if(m_muxtype == 3) str += _T(".dsm");
  1494. }
  1496. m_file = str;
  1498. UpdateData(FALSE);
  1499. }
  1501. UpdateOutputControls();
  1502. }
  1504. void CPlayerCaptureDialog::OnRecord()
  1505. {
  1506. UpdateData();
  1508. CMainFrame* pFrame = (CMainFrame*)AfxGetMainWnd();
  1509. if(!pFrame) return;
  1511. if(!pFrame->m_fCapturing)
  1512. {
  1513. UpdateMuxer();
  1515. CComQIPtr<IFileSinkFilter2> pFSF = m_pMux;
  1516. if(pFSF)
  1517. {
  1518. m_pDst = m_pMux;
  1519. }
  1520. else
  1521. {
  1522. m_pDst = NULL;
  1523. m_pDst.CoCreateInstance(CLSID_FileWriter);
  1524. pFSF = m_pDst;
  1525. }
  1527. if(!pFSF
  1528. || FAILED(pFSF->SetFileName(CStringW(m_file), NULL))
  1529. || FAILED(pFSF->SetMode(AM_FILE_OVERWRITE)))
  1530. {
  1531. AfxMessageBox(_T("Error initializing the output file"));
  1532. return;
  1533. }
  1535. CString audfn = m_file.Left(m_file.ReverseFind('.')+1);
  1536. if(m_fSepAudio && m_fAudOutput && m_pAudMux && !audfn.IsEmpty())
  1537. {
  1538. audfn += _T("wav");
  1540. CComQIPtr<IFileSinkFilter2> pFSF = m_pAudMux;
  1541. if(pFSF)
  1542. {
  1543. m_pAudDst = m_pAudMux;
  1544. }
  1545. else
  1546. {
  1547. m_pAudDst = NULL;
  1548. m_pAudDst.CoCreateInstance(CLSID_FileWriter);
  1549. pFSF = m_pAudDst;
  1550. }
  1552. if(!pFSF
  1553. || FAILED(pFSF->SetFileName(CStringW(audfn), NULL))
  1554. || FAILED(pFSF->SetMode(AM_FILE_OVERWRITE)))
  1555. {
  1556. AfxMessageBox(_T("Error initializing the audio output file"));
  1557. return;
  1558. }
  1559. }
  1561. m_pVidBuffer = m_fVidOutput && m_nVidBuffers > 0 && m_muxtype != 2 && m_muxtype != 3 ? new CBufferFilter(NULL, NULL) : NULL;
  1562. if(CComQIPtr<IBufferFilter> pVB = m_pVidBuffer)
  1563. {pVB->SetBuffers(m_nVidBuffers); pVB->SetPriority(THREAD_PRIORITY_NORMAL);}
  1565. m_pAudBuffer = m_fAudOutput && m_nAudBuffers > 0 && m_muxtype != 2 && m_muxtype != 3 ? new CBufferFilter(NULL, NULL) : NULL;
  1566. if(CComQIPtr<IBufferFilter> pAB = m_pAudBuffer)
  1567. {pAB->SetBuffers(m_nAudBuffers); pAB->SetPriority(THREAD_PRIORITY_ABOVE_NORMAL);}
  1569. EnableControls(this, false);
  1571. pFrame->StartCapture();
  1573. SetTimer(1, 100, NULL);
  1574. }
  1575. else
  1576. {
  1577. KillTimer(1);
  1579. pFrame->StopCapture();
  1580. /*
  1581. {
  1582. if(FILE* f = _tfopen(m_file, _T("rb+")))
  1583. {
  1584. fseek(f, 0x20, SEEK_SET);
  1585. unsigned short mspf = (unsigned short)(((VIDEOINFOHEADER*)m_mtv.pbFormat)->AvgTimePerFrame / 10);
  1586. fwrite(&mspf, 1, 2, f);
  1587. fclose(f);
  1588. }
  1589. }
  1590. */
  1591. EnableControls(this, true);
  1593. m_pVidBuffer = NULL;
  1594. m_pAudBuffer = NULL;
  1595. }
  1596. }
  1598. void CPlayerCaptureDialog::OnEnChangeEdit9()
  1599. {
  1600. UpdateData();
  1601. AfxGetApp()->WriteProfileInt(_T("Capture"), _T("VidBuffers"), max(m_nVidBuffers, 0));
  1602. }
  1604. void CPlayerCaptureDialog::OnEnChangeEdit12()
  1605. {
  1606. UpdateData();
  1607. AfxGetApp()->WriteProfileInt(_T("Capture"), _T("AudBuffers"), max(m_nAudBuffers, 0));
  1608. }
  1610. void CPlayerCaptureDialog::OnTimer(UINT nIDEvent)
  1611. {
  1612. if(nIDEvent == 1)
  1613. {
  1614. if(((CMainFrame*)AfxGetMainWnd())->m_fCapturing)
  1615. {
  1616. ULARGE_INTEGER FreeBytesAvailable, TotalNumberOfBytes, TotalNumberOfFreeBytes;
  1617. if(GetDiskFreeSpaceEx(m_file.Left(m_file.ReverseFind('\')+1), &FreeBytesAvailable, &TotalNumberOfBytes, &TotalNumberOfFreeBytes)
  1618. && FreeBytesAvailable.QuadPart < 1024i64*1024*10)
  1619. {
  1620. OnRecord();
  1621. }
  1622. }
  1623. }
  1625. __super::OnTimer(nIDEvent);
  1626. }
  1628. void CPlayerCaptureDialog::OnBnClickedVidAudPreview()
  1629. {
  1630. UpdateData();
  1631. UpdateGraph();
  1632. }
  1634. void CPlayerCaptureDialog::OnBnClickedCheck7()
  1635. {
  1636. // UpdateMuxer();
  1637. }
  1639. void CPlayerCaptureDialog::OnCbnSelchangeCombo14()
  1640. {
  1641. UpdateData();
  1643. CString ext = m_file.Mid(m_file.ReverseFind('.')+1).MakeLower();
  1645. if(m_muxtype == 0 && ext != _T("avi"))
  1646. m_file = m_file.Left(m_file.GetLength()-4) + _T(".avi");
  1647. else if(m_muxtype == 1 && ext != _T("ogm"))
  1648. m_file = m_file.Left(m_file.GetLength()-4) + _T(".ogm");
  1649. else if(m_muxtype == 2 && ext != _T("mkv"))
  1650. m_file = m_file.Left(m_file.GetLength()-4) + _T(".mkv");
  1651. else if(m_muxtype == 3 && ext != _T("dsm"))
  1652. m_file = m_file.Left(m_file.GetLength()-4) + _T(".dsm");
  1654. UpdateData(FALSE);
  1656. GetDlgItem(IDC_EDIT9)->EnableWindow(m_muxtype != 2 && m_muxtype != 3);
  1657. GetDlgItem(IDC_EDIT12)->EnableWindow(m_muxtype != 2 && m_muxtype != 3);
  1659. m_recordbtn.EnableWindow(m_muxtype != 1 || m_fEnableOgm);
  1660. }