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

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

多媒体编程

开发平台：

Visual C++

RoQSplitter.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. #include "StdAfx.h"
  23. #include <initguid.h>
  24. #include "RoQSplitter.h"
  25. #include "........includemoreuuids.h"
  27. #ifdef REGISTER_FILTER
  29. const AMOVIESETUP_MEDIATYPE sudPinTypesIn[] =
  30. {
  31. {&MEDIATYPE_Stream, &MEDIASUBTYPE_RoQ},
  32. {&MEDIATYPE_Stream, &MEDIASUBTYPE_NULL},
  33. };
  35. const AMOVIESETUP_PIN sudpPins[] =
  36. {
  37.     {L"Input", FALSE, FALSE, FALSE, FALSE, &CLSID_NULL, NULL, countof(sudPinTypesIn), sudPinTypesIn},
  38.     {L"Output", FALSE, TRUE, FALSE, FALSE, &CLSID_NULL, NULL, 0, NULL}
  39. };
  41. const AMOVIESETUP_MEDIATYPE sudPinTypesIn2[] =
  42. {
  43. {&MEDIATYPE_Video, &MEDIASUBTYPE_RoQV},
  44. };
  46. const AMOVIESETUP_MEDIATYPE sudPinTypesOut2[] =
  47. {
  48. {&MEDIATYPE_Video, &MEDIASUBTYPE_NULL},
  49. };
  51. const AMOVIESETUP_PIN sudpPins2[] =
  52. {
  53.     {L"Input", FALSE, FALSE, FALSE, FALSE, &CLSID_NULL, NULL, countof(sudPinTypesIn2), sudPinTypesIn2},
  54.     {L"Output", FALSE, TRUE, FALSE, FALSE, &CLSID_NULL, NULL, countof(sudPinTypesOut2), sudPinTypesOut2}
  55. };
  57. const AMOVIESETUP_MEDIATYPE sudPinTypesIn3[] =
  58. {
  59. {&MEDIATYPE_Audio, &MEDIASUBTYPE_RoQA},
  60. };
  62. const AMOVIESETUP_MEDIATYPE sudPinTypesOut3[] =
  63. {
  64. {&MEDIATYPE_Audio, &MEDIASUBTYPE_PCM},
  65. };
  67. const AMOVIESETUP_PIN sudpPins3[] =
  68. {
  69.     {L"Input", FALSE, FALSE, FALSE, FALSE, &CLSID_NULL, NULL, countof(sudPinTypesIn3), sudPinTypesIn3},
  70.     {L"Output", FALSE, TRUE, FALSE, FALSE, &CLSID_NULL, NULL, countof(sudPinTypesOut3), sudPinTypesOut3}
  71. };
  73. const AMOVIESETUP_FILTER sudFilter[] =
  74. {
  75. {&__uuidof(CRoQSplitterFilter), L"RoQ Splitter", MERIT_NORMAL+1, countof(sudpPins), sudpPins},
  76. {&__uuidof(CRoQSourceFilter), L"RoQ Source", MERIT_NORMAL+1, 0, NULL},
  77. {&__uuidof(CRoQVideoDecoder), L"RoQ Video Decoder", MERIT_UNLIKELY, countof(sudpPins2), sudpPins2},
  78. {&__uuidof(CRoQAudioDecoder), L"RoQ Audio Decoder", MERIT_UNLIKELY, countof(sudpPins3), sudpPins3},
  79. };
  81. CFactoryTemplate g_Templates[] =
  82. {
  83. {sudFilter[0].strName, sudFilter[0].clsID, CreateInstance<CRoQSplitterFilter>, NULL, &sudFilter[0]},
  84. {sudFilter[1].strName, sudFilter[1].clsID, CreateInstance<CRoQSourceFilter>, NULL, &sudFilter[1]},
  85.     {sudFilter[2].strName, sudFilter[2].clsID, CreateInstance<CRoQVideoDecoder>, NULL, &sudFilter[2]},
  86.     {sudFilter[3].strName, sudFilter[3].clsID, CreateInstance<CRoQAudioDecoder>, NULL, &sudFilter[3]},
  87. };
  89. int g_cTemplates = countof(g_Templates);
  91. STDAPI DllRegisterServer()
  92. {
  93. RegisterSourceFilter(CLSID_AsyncReader, MEDIASUBTYPE_RoQ, _T("0,8,,8410FFFFFFFF1E00"), _T(".roq"), NULL);
  95. return AMovieDllRegisterServer2(TRUE);
  96. }
  98. STDAPI DllUnregisterServer()
  99. {
  100. UnRegisterSourceFilter(MEDIASUBTYPE_RoQ);
  102. return AMovieDllRegisterServer2(FALSE);
  103. }
  105. extern "C" BOOL WINAPI DllEntryPoint(HINSTANCE, ULONG, LPVOID);
  107. BOOL APIENTRY DllMain(HANDLE hModule, DWORD dwReason, LPVOID lpReserved)
  108. {
  109.     return DllEntryPoint((HINSTANCE)hModule, dwReason, 0); // "DllMain" of the dshow baseclasses;
  110. }
  112. #endif
  114. //
  115. // CRoQSplitterFilter
  116. //
  118. CRoQSplitterFilter::CRoQSplitterFilter(LPUNKNOWN pUnk, HRESULT* phr)
  119. : CBaseSplitterFilter(NAME("CRoQSplitterFilter"), pUnk, phr, __uuidof(this))
  120. {
  121. }
  123. HRESULT CRoQSplitterFilter::CreateOutputs(IAsyncReader* pAsyncReader)
  124. {
  125. CheckPointer(pAsyncReader, E_POINTER);
  127. HRESULT hr = E_FAIL;
  129. m_pAsyncReader = pAsyncReader;
  131. UINT64 hdr = 0, hdrchk = 0x001effffffff1084;
  132. m_pAsyncReader->SyncRead(0, 8, (BYTE*)&hdr);
  133. if(hdr != hdrchk) return E_FAIL;
  135. //
  137. m_rtNewStart = m_rtCurrent = 0;
  138. m_rtNewStop = m_rtStop = m_rtDuration = 0;
  140. // pins
  142. CMediaType mt;
  143. CArray<CMediaType> mts;
  145. int iHasVideo = 0;
  146. int iHasAudio = 0;
  148. m_index.RemoveAll();
  149. __int64 audiosamples = 0;
  151. roq_info ri;
  152. memset(&ri, 0, sizeof(ri));
  154. roq_chunk rc;
  156. UINT64 pos = 8;
  158. while(S_OK == m_pAsyncReader->SyncRead(pos, sizeof(rc), (BYTE*)&rc))
  159. {
  160. pos += sizeof(rc);
  162. if(rc.id == 0x1001)
  163. {
  164. if(S_OK != m_pAsyncReader->SyncRead(pos, sizeof(ri), (BYTE*)&ri) || ri.w == 0 || ri.h == 0)
  165. break;
  166. }
  167. else if(rc.id == 0x1002 || rc.id == 0x1011)
  168. {
  169. if(!iHasVideo && ri.w > 0 && ri.h > 0)
  170. {
  171. mts.RemoveAll();
  173. mt.InitMediaType();
  174. mt.majortype = MEDIATYPE_Video;
  175. mt.subtype = MEDIASUBTYPE_RoQV;
  176. mt.formattype = FORMAT_VideoInfo;
  177. VIDEOINFOHEADER vih;
  178. memset(&vih, 0, sizeof(vih));
  179. vih.AvgTimePerFrame = 10000000i64/30;
  180. vih.bmiHeader.biSize = sizeof(vih.bmiHeader.biSize);
  181. vih.bmiHeader.biWidth = ri.w;
  182. vih.bmiHeader.biHeight = ri.h;
  183. vih.bmiHeader.biCompression = MEDIASUBTYPE_RoQV.Data1;
  184. mt.SetFormat((BYTE*)&vih, sizeof(vih));
  185. mt.lSampleSize = 1;
  187. mts.Add(mt);
  189. CAutoPtr<CBaseSplitterOutputPin> pPinOut(new CBaseSplitterOutputPin(mts, L"Video", this, this, &hr));
  190. AddOutputPin(0, pPinOut);
  191. }
  193. if(rc.id == 0x1002)
  194. {
  195. iHasVideo++;
  197. index i;
  198. i.rtv = 10000000i64*m_index.GetCount()/30;
  199. i.rta = 10000000i64*audiosamples/22050;
  200. i.fp = pos - sizeof(rc);
  201. m_index.AddTail(i);
  202. }
  203. }
  204. else if(rc.id == 0x1020 || rc.id == 0x1021)
  205. {
  206. if(!iHasAudio)
  207. {
  208. mts.RemoveAll();
  210. mt.InitMediaType();
  211. mt.majortype = MEDIATYPE_Audio;
  212. mt.subtype = MEDIASUBTYPE_RoQA;
  213. mt.formattype = FORMAT_WaveFormatEx;
  214. WAVEFORMATEX wfe;
  215. memset(&wfe, 0, sizeof(wfe));
  216. wfe.wFormatTag = (WORD)WAVE_FORMAT_RoQA; // cut into half, hehe, like anyone would care
  217. wfe.nChannels = (rc.id&1)+1;
  218. wfe.nSamplesPerSec = 22050;
  219. wfe.wBitsPerSample = 16;
  220. mt.SetFormat((BYTE*)&wfe, sizeof(wfe));
  221. mt.lSampleSize = 1;
  222. mts.Add(mt);
  224. CAutoPtr<CBaseSplitterOutputPin> pPinOut(new CBaseSplitterOutputPin(mts, L"Audio", this, this, &hr));
  225. AddOutputPin(1, pPinOut);
  226. }
  228. iHasAudio++;
  230. audiosamples += rc.size / ((rc.id&1)+1);
  231. }
  233. pos += rc.size;
  234. }
  236. //
  238. m_rtNewStop = m_rtStop = m_rtDuration = 10000000i64*iHasVideo/30;
  240. return m_pOutputs.GetCount() > 0 ? S_OK : E_FAIL;
  241. }
  243. bool CRoQSplitterFilter::DemuxInit()
  244. {
  245. m_indexpos = m_index.GetHeadPosition();
  247. return(true);
  248. }
  250. void CRoQSplitterFilter::DemuxSeek(REFERENCE_TIME rt)
  251. {
  252. if(rt <= 0)
  253. {
  254. m_indexpos = m_index.GetHeadPosition();
  255. }
  256. else
  257. {
  258. m_indexpos = m_index.GetTailPosition();
  259. while(m_indexpos && m_index.GetPrev(m_indexpos).rtv > rt);
  260. }
  261. }
  263. bool CRoQSplitterFilter::DemuxLoop()
  264. {
  265. if(!m_indexpos) return(true);
  267. index& i = m_index.GetAt(m_indexpos);
  269. REFERENCE_TIME rtVideo = i.rtv, rtAudio = i.rta;
  271. HRESULT hr = S_OK;
  273. UINT64 pos = i.fp;
  275. roq_chunk rc;
  276. while(S_OK == (hr = m_pAsyncReader->SyncRead(pos, sizeof(rc), (BYTE*)&rc))
  277. && !CheckRequest(NULL))
  278. {
  279. pos += sizeof(rc);
  281. CAutoPtr<Packet> p(new Packet());
  283. if(rc.id == 0x1002 || rc.id == 0x1011 || rc.id == 0x1020 || rc.id == 0x1021)
  284. {
  285. p->pData.SetSize(sizeof(rc) + rc.size);
  286. memcpy(p->pData.GetData(), &rc, sizeof(rc));
  287. if(S_OK != (hr = m_pAsyncReader->SyncRead(pos, rc.size, p->pData.GetData() + sizeof(rc))))
  288. break;
  289. }
  291. if(rc.id == 0x1002 || rc.id == 0x1011)
  292. {
  293. p->TrackNumber = 0;
  294. p->bSyncPoint = rtVideo == 0;
  295. p->rtStart = rtVideo;
  296. p->rtStop = rtVideo += (rc.id == 0x1011 ? 10000000i64/30 : 0);
  297. TRACE(_T("v: %I64d - %I64d (%d)n"), p->rtStart/10000, p->rtStop/10000, p->pData.GetSize());
  298. }
  299. else if(rc.id == 0x1020 || rc.id == 0x1021)
  300. {
  301. int nChannels = (rc.id&1)+1;
  303. p->TrackNumber = 1;
  304. p->bSyncPoint = TRUE;
  305. p->rtStart = rtAudio;
  306. p->rtStop = rtAudio += 10000000i64*rc.size/(nChannels*22050);
  307. TRACE(_T("a: %I64d - %I64d (%d)n"), p->rtStart/10000, p->rtStop/10000, p->pData.GetSize());
  308. }
  310. if(rc.id == 0x1002 || rc.id == 0x1011 || rc.id == 0x1020 || rc.id == 0x1021)
  311. {
  312. hr = DeliverPacket(p);
  313. }
  315. pos += rc.size;
  316. }
  318. return(true);
  319. }
  321. //
  322. // CRoQSourceFilter
  323. //
  325. CRoQSourceFilter::CRoQSourceFilter(LPUNKNOWN pUnk, HRESULT* phr)
  326. : CRoQSplitterFilter(pUnk, phr)
  327. {
  328. m_clsid = __uuidof(this);
  329. m_pInput.Free();
  330. }
  332. //
  333. // CRoQVideoDecoder
  334. //
  336. CRoQVideoDecoder::CRoQVideoDecoder(LPUNKNOWN lpunk, HRESULT* phr)
  337. : CTransformFilter(NAME("CRoQVideoDecoder"), lpunk, __uuidof(this))
  338. {
  339. if(phr) *phr = S_OK;
  340. }
  342. CRoQVideoDecoder::~CRoQVideoDecoder()
  343. {
  344. }
  346. void CRoQVideoDecoder::apply_vector_2x2(int x, int y, roq_cell* cell)
  347. {
  348. unsigned char* yptr;
  349. yptr = m_y[0] + (y * m_pitch) + x;
  350. *yptr++ = cell->y0;
  351. *yptr++ = cell->y1;
  352. yptr += (m_pitch - 2);
  353. *yptr++ = cell->y2;
  354. *yptr++ = cell->y3;
  355. m_u[0][(y/2) * (m_pitch/2) + x/2] = cell->u;
  356. m_v[0][(y/2) * (m_pitch/2) + x/2] = cell->v;
  357. }
  359. void CRoQVideoDecoder::apply_vector_4x4(int x, int y, roq_cell* cell)
  360. {
  361. unsigned long row_inc, c_row_inc;
  362. register unsigned char y0, y1, u, v;
  363. unsigned char *yptr, *uptr, *vptr;
  365. yptr = m_y[0] + (y * m_pitch) + x;
  366. uptr = m_u[0] + (y/2) * (m_pitch/2) + x/2;
  367. vptr = m_v[0] + (y/2) * (m_pitch/2) + x/2;
  369. row_inc = m_pitch - 4;
  370. c_row_inc = (m_pitch/2) - 2;
  371. *yptr++ = y0 = cell->y0; *uptr++ = u = cell->u; *vptr++ = v = cell->v;
  372. *yptr++ = y0;
  373. *yptr++ = y1 = cell->y1; *uptr++ = u; *vptr++ = v;
  374. *yptr++ = y1;
  376. yptr += row_inc;
  378. *yptr++ = y0;
  379. *yptr++ = y0;
  380. *yptr++ = y1;
  381. *yptr++ = y1;
  383. yptr += row_inc; uptr += c_row_inc; vptr += c_row_inc;
  385. *yptr++ = y0 = cell->y2; *uptr++ = u; *vptr++ = v;
  386. *yptr++ = y0;
  387. *yptr++ = y1 = cell->y3; *uptr++ = u; *vptr++ = v;
  388. *yptr++ = y1;
  390. yptr += row_inc;
  392. *yptr++ = y0;
  393. *yptr++ = y0;
  394. *yptr++ = y1;
  395. *yptr++ = y1;
  396. }
  398. void CRoQVideoDecoder::apply_motion_4x4(int x, int y, unsigned char mv, char mean_x, char mean_y)
  399. {
  400. int i, mx, my;
  401. unsigned char *pa, *pb;
  403. mx = x + 8 - (mv >> 4) - mean_x;
  404. my = y + 8 - (mv & 0xf) - mean_y;
  406. pa = m_y[0] + (y * m_pitch) + x;
  407. pb = m_y[1] + (my * m_pitch) + mx;
  408. for(i = 0; i < 4; i++)
  409. {
  410. pa[0] = pb[0];
  411. pa[1] = pb[1];
  412. pa[2] = pb[2];
  413. pa[3] = pb[3];
  414. pa += m_pitch;
  415. pb += m_pitch;
  416. }
  418. pa = m_u[0] + (y/2) * (m_pitch/2) + x/2;
  419. pb = m_u[1] + (my/2) * (m_pitch/2) + (mx + 1)/2;
  420. for(i = 0; i < 2; i++)
  421. {
  422. pa[0] = pb[0];
  423. pa[1] = pb[1];
  424. pa += m_pitch/2;
  425. pb += m_pitch/2;
  426. }
  428. pa = m_v[0] + (y/2) * (m_pitch/2) + x/2;
  429. pb = m_v[1] + (my/2) * (m_pitch/2) + (mx + 1)/2;
  430. for(i = 0; i < 2; i++)
  431. {
  432. pa[0] = pb[0];
  433. pa[1] = pb[1];
  434. pa += m_pitch/2;
  435. pb += m_pitch/2;
  436. }
  437. }
  439. void CRoQVideoDecoder::apply_motion_8x8(int x, int y, unsigned char mv, char mean_x, char mean_y)
  440. {
  441. int mx, my, i;
  442. unsigned char *pa, *pb;
  444. mx = x + 8 - (mv >> 4) - mean_x;
  445. my = y + 8 - (mv & 0xf) - mean_y;
  447. pa = m_y[0] + (y * m_pitch) + x;
  448. pb = m_y[1] + (my * m_pitch) + mx;
  449. for(i = 0; i < 8; i++)
  450. {
  451. pa[0] = pb[0];
  452. pa[1] = pb[1];
  453. pa[2] = pb[2];
  454. pa[3] = pb[3];
  455. pa[4] = pb[4];
  456. pa[5] = pb[5];
  457. pa[6] = pb[6];
  458. pa[7] = pb[7];
  459. pa += m_pitch;
  460. pb += m_pitch;
  461. }
  463. pa = m_u[0] + (y/2) * (m_pitch/2) + x/2;
  464. pb = m_u[1] + (my/2) * (m_pitch/2) + (mx + 1)/2;
  465. for(i = 0; i < 4; i++)
  466. {
  467. pa[0] = pb[0];
  468. pa[1] = pb[1];
  469. pa[2] = pb[2];
  470. pa[3] = pb[3];
  471. pa += m_pitch/2;
  472. pb += m_pitch/2;
  473. }
  475. pa = m_v[0] + (y/2) * (m_pitch/2) + x/2;
  476. pb = m_v[1] + (my/2) * (m_pitch/2) + (mx + 1)/2;
  477. for(i = 0; i < 4; i++)
  478. {
  479. pa[0] = pb[0];
  480. pa[1] = pb[1];
  481. pa[2] = pb[2];
  482. pa[3] = pb[3];
  483. pa += m_pitch/2;
  484. pb += m_pitch/2;
  485. }
  486. }
  488. HRESULT CRoQVideoDecoder::NewSegment(REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
  489. {
  490. CAutoLock cAutoLock(&m_csReceive);
  492. m_rtStart = tStart;
  494. BITMAPINFOHEADER bih;
  495. ExtractBIH(&m_pInput->CurrentMediaType(), &bih);
  497. int size = bih.biWidth*bih.biHeight;
  499. memset(m_y[0], 0, size);
  500. memset(m_u[0], 0x80, size/2);
  501. memset(m_y[1], 0, size);
  502. memset(m_u[1], 0x80, size/2);
  504. return __super::NewSegment(tStart, tStop, dRate);
  505. }
  507. HRESULT CRoQVideoDecoder::Transform(IMediaSample* pIn, IMediaSample* pOut)
  508. {
  509. CAutoLock cAutoLock(&m_csReceive);
  511. HRESULT hr;
  513. AM_MEDIA_TYPE* pmt;
  514. if(SUCCEEDED(pOut->GetMediaType(&pmt)) && pmt)
  515. {
  516. CMediaType mt(*pmt);
  517. m_pOutput->SetMediaType(&mt);
  518. DeleteMediaType(pmt);
  519. }
  521. BYTE* pDataIn = NULL;
  522. if(FAILED(hr = pIn->GetPointer(&pDataIn))) return hr;
  524. long len = pIn->GetActualDataLength();
  525. if(len <= 0) return S_OK; // nothing to do
  527. REFERENCE_TIME rtStart = 0, rtStop = 0;
  528. pIn->GetTime(&rtStart, &rtStop);
  530. if(pIn->IsPreroll() == S_OK || rtStart < 0)
  531. return S_OK;
  533. BYTE* pDataOut = NULL;
  534. if(FAILED(hr = pOut->GetPointer(&pDataOut)))
  535. return hr;
  537. BITMAPINFOHEADER bih;
  538. ExtractBIH(&m_pInput->CurrentMediaType(), &bih);
  540. int w = bih.biWidth, h = bih.biHeight;
  542. // TODO: decode picture into m_pI420
  544. roq_chunk* rc = (roq_chunk*)pDataIn;
  546. pDataIn += sizeof(roq_chunk);
  548. if(rc->id == 0x1002)
  549. {
  550. DWORD nv1 = rc->arg>>8;
  551. if(nv1 == 0) nv1 = 256;
  553. DWORD nv2 = rc->arg&0xff;
  554. if(nv2 == 0 && nv1 * 6 < rc->size) nv2 = 256;
  556. memcpy(m_cells, pDataIn, sizeof(m_cells[0])*nv1);
  557. pDataIn += sizeof(m_cells[0])*nv1;
  559. for(int i = 0; i < (int)nv2; i++)
  560. for(int j = 0; j < 4; j++)
  561. m_qcells[i].idx[j] = &m_cells[*pDataIn++];
  563. return S_FALSE;
  564. }
  565. else if(rc->id == 0x1011)
  566. {
  567. int bpos = 0, xpos = 0, ypos = 0;
  568. int vqflg = 0, vqflg_pos = -1, vqid;
  569. roq_qcell* qcell = NULL;
  571. BYTE* buf = pDataIn;
  573. while(bpos < (int)rc->size && ypos < h)
  574. {
  575. for(int yp = ypos; yp < ypos + 16; yp += 8)
  576. {
  577. for(int xp = xpos; xp < xpos + 16; xp += 8)
  578. {
  579. if(vqflg_pos < 0)
  580. {
  581. vqflg = buf[bpos++];
  582. vqflg |= buf[bpos++]<<8;
  583. vqflg_pos = 7;
  584. }
  586. vqid = (vqflg >> (vqflg_pos * 2)) & 3;
  587. vqflg_pos--;
  589. switch(vqid)
  590. {
  591. case 0:
  592. break;
  593. case 1:
  594. apply_motion_8x8(xp, yp, buf[bpos++], rc->arg >> 8, rc->arg & 0xff);
  595. break;
  596. case 2:
  597. qcell = m_qcells + buf[bpos++];
  598. apply_vector_4x4(xp, yp, qcell->idx[0]);
  599. apply_vector_4x4(xp+4, yp, qcell->idx[1]);
  600. apply_vector_4x4(xp, yp+4, qcell->idx[2]);
  601. apply_vector_4x4(xp+4, yp+4, qcell->idx[3]);
  602. break;
  603. case 3:
  604. for(int k = 0; k < 4; k++)
  605. {
  606. int x = xp, y = yp;
  607. if(k&1) x += 4;
  608. if(k&2) y += 4;
  610. if(vqflg_pos < 0)
  611. {
  612. vqflg = buf[bpos++];
  613. vqflg |= buf[bpos++]<<8;
  614. vqflg_pos = 7;
  615. }
  617. vqid = (vqflg >> (vqflg_pos * 2)) & 3;
  618. vqflg_pos--;
  620. switch(vqid)
  621. {
  622. case 0:
  623. break;
  624. case 1:
  625. apply_motion_4x4(x, y, buf[bpos++], rc->arg >> 8, rc->arg & 0xff);
  626. break;
  627. case 2:
  628. qcell = m_qcells + buf[bpos++];
  629. apply_vector_2x2(x, y, qcell->idx[0]);
  630. apply_vector_2x2(x+2, y, qcell->idx[1]);
  631. apply_vector_2x2(x, y+2, qcell->idx[2]);
  632. apply_vector_2x2(x+2, y+2, qcell->idx[3]);
  633. break;
  634. case 3:
  635. apply_vector_2x2(x, y, &m_cells[buf[bpos++]]);
  636. apply_vector_2x2(x+2, y, &m_cells[buf[bpos++]]);
  637. apply_vector_2x2(x, y+2, &m_cells[buf[bpos++]]);
  638. apply_vector_2x2(x+2, y+2, &m_cells[buf[bpos++]]);
  639. break;
  640. }
  641. }
  642. break;
  643. }
  644. }
  645. }
  647. xpos += 16;
  648. if(xpos >= w) {xpos -= w; ypos += 16;}
  649. }
  651. if(m_rtStart+rtStart == 0)
  652. {
  653. memcpy(m_y[1], m_y[0], w*h*3/2);
  654. }
  655. else
  656. {
  657. BYTE* tmp;
  658. tmp = m_y[0]; m_y[0] = m_y[1]; m_y[1] = tmp;
  659. tmp = m_u[0]; m_u[0] = m_u[1]; m_u[1] = tmp;
  660. tmp = m_v[0]; m_v[0] = m_v[1]; m_v[1] = tmp;
  661. }
  662. }
  663. else
  664. {
  665. return E_UNEXPECTED;
  666. }
  668. if(rtStart < 0)
  669. return S_FALSE;
  671. Copy(pDataOut, m_y[1], w, h);
  673. pOut->SetTime(&rtStart, &rtStop);
  675. return S_OK;
  676. }
  678. void CRoQVideoDecoder::Copy(BYTE* pOut, BYTE* pIn, DWORD w, DWORD h)
  679. {
  680. BITMAPINFOHEADER bihOut;
  681. ExtractBIH(&m_pOutput->CurrentMediaType(), &bihOut);
  683. int pitchIn = w;
  684. int pitchInUV = pitchIn>>1;
  685. BYTE* pInU = pIn + pitchIn*h;
  686. BYTE* pInV = pInU + pitchInUV*h/2;
  688. if(bihOut.biCompression == '2YUY')
  689. {
  690. BitBltFromI420ToYUY2(w, h, pOut, bihOut.biWidth*2, pIn, pInU, pInV, pitchIn);
  691. }
  692. else if(bihOut.biCompression == 'I420' || bihOut.biCompression == 'VUYI')
  693. {
  694. BitBltFromI420ToI420(w, h, pOut, pOut + bihOut.biWidth*h, pOut + bihOut.biWidth*h*5/4, bihOut.biWidth, pIn, pInU, pInV, pitchIn);
  695. }
  696. else if(bihOut.biCompression == '21VY')
  697. {
  698. BitBltFromI420ToI420(w, h, pOut, pOut + bihOut.biWidth*h*5/4, pOut + bihOut.biWidth*h, bihOut.biWidth, pIn, pInU, pInV, pitchIn);
  699. }
  700. else if(bihOut.biCompression == BI_RGB || bihOut.biCompression == BI_BITFIELDS)
  701. {
  702. int pitchOut = bihOut.biWidth*bihOut.biBitCount>>3;
  704. if(bihOut.biHeight > 0)
  705. {
  706. pOut += pitchOut*(h-1);
  707. pitchOut = -pitchOut;
  708. }
  710. if(!BitBltFromI420ToRGB(w, h, pOut, pitchOut, bihOut.biBitCount, pIn, pInU, pInV, pitchIn))
  711. {
  712. for(DWORD y = 0; y < h; y++, pIn += pitchIn, pOut += pitchOut)
  713. memset(pOut, 0, pitchOut);
  714. }
  715. }
  716. }
  718. HRESULT CRoQVideoDecoder::CheckInputType(const CMediaType* mtIn)
  719. {
  720. return mtIn->majortype == MEDIATYPE_Video && mtIn->subtype == MEDIASUBTYPE_RoQV
  721. ? S_OK
  722. : VFW_E_TYPE_NOT_ACCEPTED;
  723. }
  725. HRESULT CRoQVideoDecoder::CheckTransform(const CMediaType* mtIn, const CMediaType* mtOut)
  726. {
  727. if(m_pOutput && m_pOutput->IsConnected())
  728. {
  729. BITMAPINFOHEADER bih1, bih2;
  730. if(ExtractBIH(mtOut, &bih1) && ExtractBIH(&m_pOutput->CurrentMediaType(), &bih2)
  731. && abs(bih1.biHeight) != abs(bih2.biHeight))
  732. return VFW_E_TYPE_NOT_ACCEPTED;
  733. }
  735. return SUCCEEDED(CheckInputType(mtIn))
  736. && mtOut->majortype == MEDIATYPE_Video && (mtOut->subtype == MEDIASUBTYPE_YUY2
  737. || mtOut->subtype == MEDIASUBTYPE_YV12
  738. || mtOut->subtype == MEDIASUBTYPE_I420
  739. || mtOut->subtype == MEDIASUBTYPE_IYUV
  740. || mtOut->subtype == MEDIASUBTYPE_ARGB32
  741. || mtOut->subtype == MEDIASUBTYPE_RGB32
  742. || mtOut->subtype == MEDIASUBTYPE_RGB24
  743. || mtOut->subtype == MEDIASUBTYPE_RGB565
  744. || mtOut->subtype == MEDIASUBTYPE_RGB555)
  745. ? S_OK
  746. : VFW_E_TYPE_NOT_ACCEPTED;
  747. }
  749. HRESULT CRoQVideoDecoder::DecideBufferSize(IMemAllocator* pAllocator, ALLOCATOR_PROPERTIES* pProperties)
  750. {
  751. if(m_pInput->IsConnected() == FALSE) return E_UNEXPECTED;
  753. BITMAPINFOHEADER bih;
  754. ExtractBIH(&m_pOutput->CurrentMediaType(), &bih);
  756. pProperties->cBuffers = 1;
  757. pProperties->cbBuffer = bih.biSizeImage;
  758. pProperties->cbAlign = 1;
  759. pProperties->cbPrefix = 0;
  761. HRESULT hr;
  762. ALLOCATOR_PROPERTIES Actual;
  763.     if(FAILED(hr = pAllocator->SetProperties(pProperties, &Actual))) 
  764. return hr;
  766.     return(pProperties->cBuffers > Actual.cBuffers || pProperties->cbBuffer > Actual.cbBuffer
  767. ? E_FAIL
  768. : NOERROR);
  769. }
  771. HRESULT CRoQVideoDecoder::GetMediaType(int iPosition, CMediaType* pmt)
  772. {
  773.     if(m_pInput->IsConnected() == FALSE) return E_UNEXPECTED;
  775. struct {const GUID* subtype; WORD biPlanes, biBitCount; DWORD biCompression;} fmts[] =
  776. {
  777. {&MEDIASUBTYPE_YV12, 3, 12, '21VY'},
  778. {&MEDIASUBTYPE_I420, 3, 12, '024I'},
  779. {&MEDIASUBTYPE_IYUV, 3, 12, 'VUYI'},
  780. {&MEDIASUBTYPE_YUY2, 1, 16, '2YUY'},
  781. {&MEDIASUBTYPE_ARGB32, 1, 32, BI_RGB},
  782. {&MEDIASUBTYPE_RGB32, 1, 32, BI_RGB},
  783. {&MEDIASUBTYPE_RGB24, 1, 24, BI_RGB},
  784. {&MEDIASUBTYPE_RGB565, 1, 16, BI_RGB},
  785. {&MEDIASUBTYPE_RGB555, 1, 16, BI_RGB},
  786. {&MEDIASUBTYPE_ARGB32, 1, 32, BI_BITFIELDS},
  787. {&MEDIASUBTYPE_RGB32, 1, 32, BI_BITFIELDS},
  788. {&MEDIASUBTYPE_RGB24, 1, 24, BI_BITFIELDS},
  789. {&MEDIASUBTYPE_RGB565, 1, 16, BI_BITFIELDS},
  790. {&MEDIASUBTYPE_RGB555, 1, 16, BI_BITFIELDS},
  791. };
  793. if(iPosition < 0) return E_INVALIDARG;
  794. if(iPosition >= countof(fmts)) return VFW_S_NO_MORE_ITEMS;
  796. BITMAPINFOHEADER bih;
  797. ExtractBIH(&m_pInput->CurrentMediaType(), &bih);
  799. pmt->majortype = MEDIATYPE_Video;
  800. pmt->subtype = *fmts[iPosition].subtype;
  801. pmt->formattype = FORMAT_VideoInfo;
  803. BITMAPINFOHEADER bihOut;
  804. memset(&bihOut, 0, sizeof(bihOut));
  805. bihOut.biSize = sizeof(bihOut);
  806. bihOut.biWidth = bih.biWidth;
  807. bihOut.biHeight = bih.biHeight;
  808. bihOut.biPlanes = fmts[iPosition].biPlanes;
  809. bihOut.biBitCount = fmts[iPosition].biBitCount;
  810. bihOut.biCompression = fmts[iPosition].biCompression;
  811. bihOut.biSizeImage = bih.biWidth*bih.biHeight*bihOut.biBitCount>>3;
  813. VIDEOINFOHEADER* vih = (VIDEOINFOHEADER*)pmt->AllocFormatBuffer(sizeof(VIDEOINFOHEADER));
  814. memset(vih, 0, sizeof(VIDEOINFOHEADER));
  815. vih->bmiHeader = bihOut;
  817. CorrectMediaType(pmt);
  819. return S_OK;
  820. }
  822. HRESULT CRoQVideoDecoder::StartStreaming()
  823. {
  824. BITMAPINFOHEADER bih;
  825. ExtractBIH(&m_pInput->CurrentMediaType(), &bih);
  827. int size = bih.biWidth*bih.biHeight;
  829. m_y[0] = new BYTE[size*3/2];
  830. m_u[0] = m_y[0] + size;
  831. m_v[0] = m_y[0] + size*5/4;
  832. m_y[1] = new BYTE[size*3/2];
  833. m_u[1] = m_y[1] + size;
  834. m_v[1] = m_y[1] + size*5/4;
  836. m_pitch = bih.biWidth;
  838. return __super::StartStreaming();
  839. }
  841. HRESULT CRoQVideoDecoder::StopStreaming()
  842. {
  843. delete [] m_y[0]; m_y[0] = NULL;
  844. delete [] m_y[1]; m_y[1] = NULL;
  846. return __super::StopStreaming();
  847. }
  849. //
  850. // CRealAudioDecoder
  851. //
  853. CRoQAudioDecoder::CRoQAudioDecoder(LPUNKNOWN lpunk, HRESULT* phr)
  854. : CTransformFilter(NAME("CRoQAudioDecoder"), lpunk, __uuidof(this))
  855. {
  856. if(phr) *phr = S_OK;
  857. }
  859. CRoQAudioDecoder::~CRoQAudioDecoder()
  860. {
  861. }
  863. HRESULT CRoQAudioDecoder::Transform(IMediaSample* pIn, IMediaSample* pOut)
  864. {
  865. HRESULT hr;
  867. AM_MEDIA_TYPE* pmt;
  868. if(SUCCEEDED(pOut->GetMediaType(&pmt)) && pmt)
  869. {
  870. CMediaType mt(*pmt);
  871. m_pOutput->SetMediaType(&mt);
  872. DeleteMediaType(pmt);
  873. }
  875. WAVEFORMATEX* pwfe = (WAVEFORMATEX*)m_pOutput->CurrentMediaType().Format();
  877. BYTE* pDataIn = NULL;
  878. if(FAILED(hr = pIn->GetPointer(&pDataIn)))
  879. return hr;
  881. long len = pIn->GetActualDataLength();
  882. if(len <= 0) return S_OK;
  884. REFERENCE_TIME rtStart, rtStop;
  885. pIn->GetTime(&rtStart, &rtStop);
  887. if(pIn->IsPreroll() == S_OK || rtStart < 0)
  888. return S_OK;
  890. BYTE* pDataOut = NULL;
  891. if(FAILED(hr = pOut->GetPointer(&pDataOut)))
  892. return hr;
  894. long size = pOut->GetSize();
  895. if(size <= 0)
  896. return E_FAIL;
  898. roq_chunk* rc = (roq_chunk*)pDataIn;
  900. WAVEFORMATEX* wfe = (WAVEFORMATEX*)m_pOutput->CurrentMediaType().Format();
  902. if(wfe->nChannels == 1)
  903. {
  904. int mono = (short)rc->arg;
  905. unsigned char* src = pDataIn + sizeof(roq_chunk);
  906. short* dst = (short*)pDataOut;
  907. for(int i = sizeof(roq_chunk); i < len; i++, src++, dst++)
  908. {
  909. short diff = (*src&0x7f)*(*src&0x7f);
  910. if(*src&0x80) diff = -diff;
  911. mono += diff;
  912. *dst = (short)mono;
  913. }
  914. }
  915. else if(wfe->nChannels == 2)
  916. {
  917. int left = (char)(rc->arg>>8)<<8;
  918. int right = (char)(rc->arg)<<8;
  919. unsigned char* src = pDataIn + sizeof(roq_chunk);
  920. short* dst = (short*)pDataOut;
  921. for(int i = sizeof(roq_chunk); i < len; i+=2, src++, dst++)
  922. {
  923. short diff = (*src&0x7f)*(*src&0x7f);
  924. if(*src&0x80) diff = -diff;
  925. ASSERT((int)left + diff <= SHRT_MAX && (int)left + diff >= SHRT_MIN);
  926. left += diff;
  927. *dst = (short)left;
  929. src++; dst++;
  931. diff = (*src&0x7f)*(*src&0x7f);
  932. if(*src&0x80) diff = -diff;
  933. ASSERT((int)right + diff <= SHRT_MAX && (int)right + diff >= SHRT_MIN);
  934. right += diff;
  935. *dst = (short)right;
  936. }
  937. }
  938. else
  939. {
  940. return E_UNEXPECTED;
  941. }
  943. pOut->SetTime(&rtStart, &rtStop);
  945. pOut->SetActualDataLength(2*(len-sizeof(roq_chunk)));
  947. return S_OK;
  948. }
  950. HRESULT CRoQAudioDecoder::CheckInputType(const CMediaType* mtIn)
  951. {
  952. return mtIn->majortype == MEDIATYPE_Audio && mtIn->subtype == MEDIASUBTYPE_RoQA
  953. ? S_OK
  954. : VFW_E_TYPE_NOT_ACCEPTED;
  955. }
  957. HRESULT CRoQAudioDecoder::CheckTransform(const CMediaType* mtIn, const CMediaType* mtOut)
  958. {
  959. return SUCCEEDED(CheckInputType(mtIn))
  960. && mtOut->majortype == MEDIATYPE_Audio && mtOut->subtype == MEDIASUBTYPE_PCM
  961. ? S_OK
  962. : VFW_E_TYPE_NOT_ACCEPTED;
  963. }
  965. HRESULT CRoQAudioDecoder::DecideBufferSize(IMemAllocator* pAllocator, ALLOCATOR_PROPERTIES* pProperties)
  966. {
  967. if(m_pInput->IsConnected() == FALSE) return E_UNEXPECTED;
  969. CComPtr<IMemAllocator> pAllocatorIn;
  970. m_pInput->GetAllocator(&pAllocatorIn);
  971. if(!pAllocatorIn) return E_UNEXPECTED;
  973. WAVEFORMATEX* wfe = (WAVEFORMATEX*)m_pOutput->CurrentMediaType().Format();
  975. // ok, maybe this is too much...
  976. pProperties->cBuffers = 8;
  977. pProperties->cbBuffer = wfe->nChannels*wfe->nSamplesPerSec*wfe->wBitsPerSample>>3; // nAvgBytesPerSec;
  978. pProperties->cbAlign = 1;
  979. pProperties->cbPrefix = 0;
  981. HRESULT hr;
  982. ALLOCATOR_PROPERTIES Actual;
  983.     if(FAILED(hr = pAllocator->SetProperties(pProperties, &Actual))) 
  984. return hr;
  986.     return pProperties->cBuffers > Actual.cBuffers || pProperties->cbBuffer > Actual.cbBuffer
  987. ? E_FAIL
  988. : NOERROR;
  989. }
  991. HRESULT CRoQAudioDecoder::GetMediaType(int iPosition, CMediaType* pmt)
  992. {
  993.     if(m_pInput->IsConnected() == FALSE) return E_UNEXPECTED;
  995. if(iPosition < 0) return E_INVALIDARG;
  996. if(iPosition > 0) return VFW_S_NO_MORE_ITEMS;
  998. *pmt = m_pInput->CurrentMediaType();
  999. pmt->subtype = MEDIASUBTYPE_PCM;
  1001. WAVEFORMATEX* wfe = (WAVEFORMATEX*)pmt->ReallocFormatBuffer(sizeof(WAVEFORMATEX));
  1002. wfe->cbSize = 0;
  1003. wfe->wFormatTag = WAVE_FORMAT_PCM;
  1004. wfe->nBlockAlign = wfe->nChannels*wfe->wBitsPerSample>>3;
  1005. wfe->nAvgBytesPerSec = wfe->nSamplesPerSec*wfe->nBlockAlign;
  1007. return S_OK;
  1008. }