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

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

多媒体编程

开发平台：

Visual C++

Mpeg2DecFilter.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 <math.h>
  24. #include <atlbase.h>
  25. #include <ks.h>
  26. #include <ksmedia.h>
  27. #include "libmpeg2.h"
  28. #include "Mpeg2DecFilter.h"
  30. #include "......DSUtilDSUtil.h"
  31. #include "......DSUtilMediaTypes.h"
  33. #include <initguid.h>
  34. #include "........includemoreuuids.h"
  35. #include "........includematroskamatroska.h"
  37. #ifdef REGISTER_FILTER
  39. const AMOVIESETUP_MEDIATYPE sudPinTypesIn[] =
  40. {
  41. {&MEDIATYPE_DVD_ENCRYPTED_PACK, &MEDIASUBTYPE_MPEG2_VIDEO},
  42. {&MEDIATYPE_MPEG2_PACK, &MEDIASUBTYPE_MPEG2_VIDEO},
  43. {&MEDIATYPE_MPEG2_PES, &MEDIASUBTYPE_MPEG2_VIDEO},
  44. {&MEDIATYPE_Video, &MEDIASUBTYPE_MPEG2_VIDEO},
  45. {&MEDIATYPE_Video, &MEDIASUBTYPE_MPEG1Packet},
  46. {&MEDIATYPE_Video, &MEDIASUBTYPE_MPEG1Payload},
  47. };
  49. const AMOVIESETUP_MEDIATYPE sudPinTypesOut[] =
  50. {
  51. {&MEDIATYPE_Video, &MEDIASUBTYPE_IYUV},
  52. };
  54. const AMOVIESETUP_PIN sudpPins[] =
  55. {
  56.     {L"Input", FALSE, FALSE, FALSE, FALSE, &CLSID_NULL, NULL, countof(sudPinTypesIn), sudPinTypesIn},
  57.     {L"Output", FALSE, TRUE, FALSE, FALSE, &CLSID_NULL, NULL, countof(sudPinTypesOut), sudPinTypesOut}
  58. };
  60. const AMOVIESETUP_FILTER sudFilter[] =
  61. {
  62. {&__uuidof(CMpeg2DecFilter), L"Mpeg2Dec Filter", 0x40000002, countof(sudpPins), sudpPins},
  63. };
  65. CFactoryTemplate g_Templates[] =
  66. {
  67.     {sudFilter[0].strName, sudFilter[0].clsID, CreateInstance<CMpeg2DecFilter>, NULL, &sudFilter[0]},
  68. };
  70. int g_cTemplates = countof(g_Templates);
  72. STDAPI DllRegisterServer()
  73. {
  74. return AMovieDllRegisterServer2(TRUE);
  75. }
  77. STDAPI DllUnregisterServer()
  78. {
  79. return AMovieDllRegisterServer2(FALSE);
  80. }
  82. //
  84. #include "........includedetoursdetours.h"
  86. DETOUR_TRAMPOLINE(BOOL WINAPI Real_IsDebuggerPresent(), IsDebuggerPresent);
  87. BOOL WINAPI Mine_IsDebuggerPresent()
  88. {
  89. TRACE(_T("Oops, somebody was trying to be naughty! (called IsDebuggerPresent)n")); 
  90. return FALSE;
  91. }
  93. DETOUR_TRAMPOLINE(LONG WINAPI Real_ChangeDisplaySettingsExA(LPCSTR lpszDeviceName, LPDEVMODEA lpDevMode, HWND hwnd, DWORD dwFlags, LPVOID lParam), ChangeDisplaySettingsExA);
  94. DETOUR_TRAMPOLINE(LONG WINAPI Real_ChangeDisplaySettingsExW(LPCWSTR lpszDeviceName, LPDEVMODEW lpDevMode, HWND hwnd, DWORD dwFlags, LPVOID lParam), ChangeDisplaySettingsExW);
  95. LONG WINAPI Mine_ChangeDisplaySettingsEx(LONG ret, DWORD dwFlags, LPVOID lParam)
  96. {
  97. if(dwFlags&CDS_VIDEOPARAMETERS)
  98. {
  99. VIDEOPARAMETERS* vp = (VIDEOPARAMETERS*)lParam;
  101. if(vp->Guid == GUIDFromCString(_T("{02C62061-1097-11d1-920F-00A024DF156E}"))
  102. && (vp->dwFlags&VP_FLAGS_COPYPROTECT))
  103. {
  104. if(vp->dwCommand == VP_COMMAND_GET)
  105. {
  106. if((vp->dwTVStandard&VP_TV_STANDARD_WIN_VGA) && vp->dwTVStandard != VP_TV_STANDARD_WIN_VGA)
  107. {
  108. TRACE(_T("Ooops, tv-out enabled? macrovision checks suck..."));
  109. vp->dwTVStandard = VP_TV_STANDARD_WIN_VGA;
  110. }
  111. }
  112. else if(vp->dwCommand == VP_COMMAND_SET)
  113. {
  114. TRACE(_T("Ooops, as I already told ya, no need for any macrovision bs here"));
  115. return 0;
  116. }
  117. }
  118. }
  120. return ret;
  121. }
  122. LONG WINAPI Mine_ChangeDisplaySettingsExA(LPCSTR lpszDeviceName, LPDEVMODEA lpDevMode, HWND hwnd, DWORD dwFlags, LPVOID lParam)
  123. {
  124. return Mine_ChangeDisplaySettingsEx(Real_ChangeDisplaySettingsExA(lpszDeviceName, lpDevMode, hwnd, dwFlags, lParam), dwFlags, lParam);
  125. }
  126. LONG WINAPI Mine_ChangeDisplaySettingsExW(LPCWSTR lpszDeviceName, LPDEVMODEW lpDevMode, HWND hwnd, DWORD dwFlags, LPVOID lParam)
  127. {
  128. return Mine_ChangeDisplaySettingsEx(Real_ChangeDisplaySettingsExW(lpszDeviceName, lpDevMode, hwnd, dwFlags, lParam), dwFlags, lParam);
  129. }
  131. bool fDetourInited = false;
  133. //
  135. extern "C" BOOL WINAPI DllEntryPoint(HINSTANCE, ULONG, LPVOID);
  137. BOOL APIENTRY DllMain(HANDLE hModule, DWORD dwReason, LPVOID lpReserved)
  138. {
  139. if(!fDetourInited)
  140. {
  141. DetourFunctionWithTrampoline((PBYTE)Real_IsDebuggerPresent, (PBYTE)Mine_IsDebuggerPresent);
  142. DetourFunctionWithTrampoline((PBYTE)Real_ChangeDisplaySettingsExA, (PBYTE)Mine_ChangeDisplaySettingsExA);
  143. DetourFunctionWithTrampoline((PBYTE)Real_ChangeDisplaySettingsExW, (PBYTE)Mine_ChangeDisplaySettingsExW);
  144. fDetourInited = true;
  145. }
  147. return DllEntryPoint((HINSTANCE)hModule, dwReason, 0); // "DllMain" of the dshow baseclasses;
  148. }
  150. #endif
  152. //
  153. // CMpeg2DecFilter
  154. //
  156. CMpeg2DecFilter::CMpeg2DecFilter(LPUNKNOWN lpunk, HRESULT* phr) 
  157. : CBaseVideoFilter(NAME("CMpeg2DecFilter"), lpunk, phr, __uuidof(this))
  158. , m_fWaitForKeyFrame(true)
  159. {
  160. delete m_pInput;
  162. if(FAILED(*phr)) return;
  164. if(!(m_pInput = new CMpeg2DecInputPin(this, phr, L"Video"))) *phr = E_OUTOFMEMORY;
  165. if(FAILED(*phr)) return;
  167. if(!(m_pSubpicInput = new CSubpicInputPin(this, phr))) *phr = E_OUTOFMEMORY;
  168. if(FAILED(*phr)) return;
  170. if(!(m_pClosedCaptionOutput = new CClosedCaptionOutputPin(this, m_pLock, phr))) *phr = E_OUTOFMEMORY;
  171. if(FAILED(*phr)) return;
  173. SetDeinterlaceMethod(DIAuto);
  174. SetBrightness(0.0);
  175. SetContrast(1.0);
  176. SetHue(0.0);
  177. SetSaturation(1.0);
  178. EnableForcedSubtitles(true);
  179. EnablePlanarYUV(true);
  181. m_rate.Rate = 10000;
  182. m_rate.StartTime = 0;
  183. }
  185. CMpeg2DecFilter::~CMpeg2DecFilter()
  186. {
  187. delete m_pSubpicInput;
  188. delete m_pClosedCaptionOutput;
  189. }
  191. STDMETHODIMP CMpeg2DecFilter::NonDelegatingQueryInterface(REFIID riid, void** ppv)
  192. {
  193. return
  194. QI(IMpeg2DecFilter)
  195.  __super::NonDelegatingQueryInterface(riid, ppv);
  196. }
  198. int CMpeg2DecFilter::GetPinCount()
  199. {
  200. return 4;
  201. }
  203. CBasePin* CMpeg2DecFilter::GetPin(int n)
  204. {
  205. switch(n)
  206. {
  207. case 0: return m_pInput;
  208. case 1: return m_pOutput;
  209. case 2: return m_pSubpicInput;
  210. case 3: return m_pClosedCaptionOutput;
  211. }
  212. return NULL;
  213. }
  215. HRESULT CMpeg2DecFilter::EndOfStream()
  216. {
  217. CAutoLock cAutoLock(&m_csReceive);
  218. m_pClosedCaptionOutput->EndOfStream();
  219. return __super::EndOfStream();
  220. }
  222. HRESULT CMpeg2DecFilter::BeginFlush()
  223. {
  224. m_pClosedCaptionOutput->DeliverBeginFlush();
  225. return __super::BeginFlush();
  226. }
  228. HRESULT CMpeg2DecFilter::EndFlush()
  229. {
  230. m_pClosedCaptionOutput->DeliverEndFlush();
  231. return __super::EndFlush();
  232. }
  234. HRESULT CMpeg2DecFilter::NewSegment(REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
  235. {
  236. CAutoLock cAutoLock(&m_csReceive);
  237. m_pClosedCaptionOutput->DeliverNewSegment(tStart, tStop, dRate);
  238. m_fDropFrames = false;
  239. return __super::NewSegment(tStart, tStop, dRate);
  240. }
  242. void CMpeg2DecFilter::InputTypeChanged()
  243. {
  244. CAutoLock cAutoLock(&m_csReceive);
  246. TRACE(_T("ResetMpeg2Decoder()n"));
  248. for(int i = 0; i < countof(m_dec->m_pictures); i++)
  249. {
  250. m_dec->m_pictures[i].rtStart = m_dec->m_pictures[i].rtStop = _I64_MIN+1;
  251. m_dec->m_pictures[i].fDelivered = false;
  252. m_dec->m_pictures[i].flags &= ~PIC_MASK_CODING_TYPE;
  253. }
  255. CMediaType& mt = m_pInput->CurrentMediaType();
  257. BYTE* pSequenceHeader = NULL;
  258. DWORD cbSequenceHeader = 0;
  260. if(mt.formattype == FORMAT_MPEGVideo)
  261. {
  262. pSequenceHeader = ((MPEG1VIDEOINFO*)mt.Format())->bSequenceHeader;
  263. cbSequenceHeader = ((MPEG1VIDEOINFO*)mt.Format())->cbSequenceHeader;
  264. }
  265. else if(mt.formattype == FORMAT_MPEG2_VIDEO)
  266. {
  267. pSequenceHeader = (BYTE*)((MPEG2VIDEOINFO*)mt.Format())->dwSequenceHeader;
  268. cbSequenceHeader = ((MPEG2VIDEOINFO*)mt.Format())->cbSequenceHeader;
  269. }
  271. m_dec->mpeg2_close();
  272. m_dec->mpeg2_init();
  274. m_dec->mpeg2_buffer(pSequenceHeader, pSequenceHeader + cbSequenceHeader);
  276. m_fWaitForKeyFrame = true;
  278. m_fFilm = false;
  279. m_fb.flags = 0;
  280. }
  282. HRESULT CMpeg2DecFilter::Transform(IMediaSample* pIn)
  283. {
  284. HRESULT hr;
  286. BYTE* pDataIn = NULL;
  287. if(FAILED(hr = pIn->GetPointer(&pDataIn)))
  288. return hr;
  290. long len = pIn->GetActualDataLength();
  292. ((CDeCSSInputPin*)m_pInput)->StripPacket(pDataIn, len);
  294. if(pIn->IsDiscontinuity() == S_OK)
  295. {
  296. InputTypeChanged();
  297. }
  299. REFERENCE_TIME rtStart = _I64_MIN, rtStop = _I64_MIN;
  300. hr = pIn->GetTime(&rtStart, &rtStop);
  301. if(FAILED(hr)) rtStart = rtStop = _I64_MIN;
  303. while(len >= 0)
  304. {
  305. mpeg2_state_t state = m_dec->mpeg2_parse();
  307. __asm emms; // this one is missing somewhere in the precompiled mmx obj files
  309. switch(state)
  310. {
  311. case STATE_BUFFER:
  312. if(len == 0) len = -1;
  313. else {m_dec->mpeg2_buffer(pDataIn, pDataIn + len); len = 0;}
  314. break;
  315. case STATE_INVALID:
  316. TRACE(_T("STATE_INVALIDn"));
  317. // if(m_fWaitForKeyFrame)
  318. // ResetMpeg2Decoder();
  319. break;
  320. case STATE_GOP:
  321. // TRACE(_T("STATE_GOPn"));
  322. if(m_dec->m_info.m_user_data_len > 4 && *(DWORD*)m_dec->m_info.m_user_data == 0xf8014343
  323. && m_pClosedCaptionOutput->IsConnected())
  324. {
  325. CComPtr<IMediaSample> pSample;
  326. m_pClosedCaptionOutput->GetDeliveryBuffer(&pSample, NULL, NULL, 0);
  327. BYTE* pData = NULL;
  328. pSample->GetPointer(&pData);
  329. *(DWORD*)pData = 0xb2010000;
  330. memcpy(pData + 4, m_dec->m_info.m_user_data, m_dec->m_info.m_user_data_len);
  331. pSample->SetActualDataLength(m_dec->m_info.m_user_data_len + 4);
  332. m_pClosedCaptionOutput->Deliver(pSample);
  333. }
  334. break;
  335. case STATE_SEQUENCE:
  336. TRACE(_T("STATE_SEQUENCEn"));
  337. m_AvgTimePerFrame = 10i64 * m_dec->m_info.m_sequence->frame_period / 27;
  338. if(m_AvgTimePerFrame == 0) m_AvgTimePerFrame = ((VIDEOINFOHEADER*)m_pInput->CurrentMediaType().Format())->AvgTimePerFrame;
  339. break;
  340. case STATE_PICTURE:
  341. /* {
  342. TCHAR frametype[] = {'?','I', 'P', 'B', 'D'};
  343. TRACE(_T("STATE_PICTURE %010I64d [%c]n"), rtStart, frametype[m_dec->m_picture->flags&PIC_MASK_CODING_TYPE]);
  344. }
  345. */ m_dec->m_picture->rtStart = rtStart;
  346. rtStart = _I64_MIN;
  347. m_dec->m_picture->fDelivered = false;
  349. m_dec->mpeg2_skip(m_fDropFrames && (m_dec->m_picture->flags&PIC_MASK_CODING_TYPE) == PIC_FLAG_CODING_TYPE_B);
  351. break;
  352. case STATE_SLICE:
  353. case STATE_END:
  354. {
  355. mpeg2_picture_t* picture = m_dec->m_info.m_display_picture;
  356. mpeg2_picture_t* picture_2nd = m_dec->m_info.m_display_picture_2nd;
  357. mpeg2_fbuf_t* fbuf = m_dec->m_info.m_display_fbuf;
  359. if(picture && fbuf && !(picture->flags&PIC_FLAG_SKIP))
  360. {
  361. ASSERT(!picture->fDelivered);
  363. // start - end
  365. m_fb.rtStart = picture->rtStart;
  366. if(m_fb.rtStart == _I64_MIN) m_fb.rtStart = m_fb.rtStop;
  367. m_fb.rtStop = m_fb.rtStart + m_AvgTimePerFrame * picture->nb_fields / (picture_2nd ? 1 : 2);
  369. REFERENCE_TIME rtStart = m_fb.rtStart;
  370. REFERENCE_TIME rtStop = m_fb.rtStop;
  372. // flags
  374. if(!(m_dec->m_info.m_sequence->flags&SEQ_FLAG_PROGRESSIVE_SEQUENCE)
  375. && (picture->flags&PIC_FLAG_PROGRESSIVE_FRAME))
  376. {
  377. if(!m_fFilm
  378. && (picture->flags&PIC_FLAG_REPEAT_FIRST_FIELD)
  379. && !(m_fb.flags&PIC_FLAG_REPEAT_FIRST_FIELD))
  380. {
  381. TRACE(_T("m_fFilm = truen"));
  382. m_fFilm = true;
  383. }
  384. else if(m_fFilm
  385. && !(picture->flags&PIC_FLAG_REPEAT_FIRST_FIELD)
  386. && !(m_fb.flags&PIC_FLAG_REPEAT_FIRST_FIELD))
  387. {
  388. TRACE(_T("m_fFilm = falsen"));
  389. m_fFilm = false;
  390. }
  391. }
  393. m_fb.flags = picture->flags;
  395. ASSERT(!(m_fb.flags&PIC_FLAG_SKIP));
  397. // frame buffer
  399. int w = m_dec->m_info.m_sequence->picture_width;
  400. int h = m_dec->m_info.m_sequence->picture_height;
  401. int pitch = m_dec->m_info.m_sequence->width;
  403. if(m_fb.w != w || m_fb.h != h || m_fb.pitch != pitch)
  404. m_fb.alloc(w, h, pitch);
  406. // deinterlace
  408. ditype di = GetDeinterlaceMethod();
  410. if(di == DIAuto || di != DIWeave && di != DIBlend && di != DIBob)
  411. {
  412. if(!!(m_dec->m_info.m_sequence->flags&SEQ_FLAG_PROGRESSIVE_SEQUENCE))
  413. di = DIWeave; // hurray!
  414. else if(m_fFilm)
  415. di = DIWeave; // we are lucky
  416. else if(!(m_fb.flags&PIC_FLAG_PROGRESSIVE_FRAME))
  417. di = DIBlend; // ok, clear thing
  418. else
  419. // big trouble here, the progressive_frame bit is not reliable :'(
  420. // frames without temporal field diffs can be only detected when ntsc 
  421. // uses the repeat field flag (signaled with m_fFilm), if it's not set 
  422. // or we have pal then we might end up blending the fields unnecessarily...
  423. di = DIBlend;
  424. // TODO: find out if the pic is really interlaced by analysing it
  425. }
  427. if(di == DIWeave)
  428. {
  429. BitBltFromI420ToI420(w, h, 
  430. m_fb.buf[0], m_fb.buf[1], m_fb.buf[2], pitch, 
  431. fbuf->buf[0], fbuf->buf[1], fbuf->buf[2], pitch);
  432. }
  433. else if(di == DIBlend)
  434. {
  435. DeinterlaceBlend(m_fb.buf[0], fbuf->buf[0], w, h, pitch, pitch);
  436. DeinterlaceBlend(m_fb.buf[1], fbuf->buf[1], w/2, h/2, pitch/2, pitch/2);
  437. DeinterlaceBlend(m_fb.buf[2], fbuf->buf[2], w/2, h/2, pitch/2, pitch/2);
  438. }
  439. else if(di == DIBob)
  440. {
  441. if(m_fb.flags&PIC_FLAG_TOP_FIELD_FIRST)
  442. {
  443. BitBltFromRGBToRGB(w, h/2, m_fb.buf[0], pitch*2, 8, fbuf->buf[0], pitch*2, 8);
  444. AvgLines8(m_fb.buf[0], h, pitch);
  445. BitBltFromRGBToRGB(w/2, h/4, m_fb.buf[1], pitch, 8, fbuf->buf[1], pitch, 8);
  446. AvgLines8(m_fb.buf[1], h/2, pitch/2);
  447. BitBltFromRGBToRGB(w/2, h/4, m_fb.buf[2], pitch, 8, fbuf->buf[2], pitch, 8);
  448. AvgLines8(m_fb.buf[2], h/2, pitch/2);
  449. }
  450. else
  451. {
  452. BitBltFromRGBToRGB(w, h/2, m_fb.buf[0]+pitch, pitch*2, 8, fbuf->buf[0]+pitch, pitch*2, 8);
  453. AvgLines8(m_fb.buf[0]+pitch, h-1, pitch);
  454. BitBltFromRGBToRGB(w/2, h/4, m_fb.buf[1]+pitch/2, pitch, 8, fbuf->buf[1]+pitch/2, pitch, 8);
  455. AvgLines8(m_fb.buf[1]+pitch/2, (h-1)/2, pitch/2);
  456. BitBltFromRGBToRGB(w/2, h/4, m_fb.buf[2]+pitch/2, pitch, 8, fbuf->buf[2]+pitch/2, pitch, 8);
  457. AvgLines8(m_fb.buf[2]+pitch/2, (h-1)/2, pitch/2);
  458. }
  460. m_fb.rtStart = rtStart;
  461. m_fb.rtStop = (rtStart + rtStop) / 2;
  462. }
  464. // postproc
  466. ApplyBrContHueSat(m_fb.buf[0], m_fb.buf[1], m_fb.buf[2], w, h, pitch);
  468. // deliver
  470. picture->fDelivered = true;
  472. if(FAILED(hr = Deliver(false)))
  473. return hr;
  475. // spec code for bob
  477. if(di == DIBob)
  478. {
  479. if(m_fb.flags&PIC_FLAG_TOP_FIELD_FIRST)
  480. {
  481. BitBltFromRGBToRGB(w, h/2, m_fb.buf[0]+pitch, pitch*2, 8, fbuf->buf[0]+pitch, pitch*2, 8);
  482. AvgLines8(m_fb.buf[0]+pitch, h-1, pitch);
  483. BitBltFromRGBToRGB(w/2, h/4, m_fb.buf[1]+pitch/2, pitch, 8, fbuf->buf[1]+pitch/2, pitch, 8);
  484. AvgLines8(m_fb.buf[1]+pitch/2, (h-1)/2, pitch/2);
  485. BitBltFromRGBToRGB(w/2, h/4, m_fb.buf[2]+pitch/2, pitch, 8, fbuf->buf[2]+pitch/2, pitch, 8);
  486. AvgLines8(m_fb.buf[2]+pitch/2, (h-1)/2, pitch/2);
  487. }
  488. else
  489. {
  490. BitBltFromRGBToRGB(w, h/2, m_fb.buf[0], pitch*2, 8, fbuf->buf[0], pitch*2, 8);
  491. AvgLines8(m_fb.buf[0], h, pitch);
  492. BitBltFromRGBToRGB(w/2, h/4, m_fb.buf[1], pitch, 8, fbuf->buf[1], pitch, 8);
  493. AvgLines8(m_fb.buf[1], h/2, pitch/2);
  494. BitBltFromRGBToRGB(w/2, h/4, m_fb.buf[2], pitch, 8, fbuf->buf[2], pitch, 8);
  495. AvgLines8(m_fb.buf[2], h/2, pitch/2);
  496. }
  498. m_fb.rtStart = (rtStart + rtStop) / 2;
  499. m_fb.rtStop = rtStop;
  501. // postproc
  503. ApplyBrContHueSat(m_fb.buf[0], m_fb.buf[1], m_fb.buf[2], w, h, pitch);
  505. // deliver
  507. picture->fDelivered = true;
  509. if(FAILED(hr = Deliver(false)))
  510. return hr;
  511. }
  512. }
  513. }
  514. break;
  515. default:
  516.     break;
  517. }
  518.     }
  520. return S_OK;
  521. }
  523. HRESULT CMpeg2DecFilter::Deliver(bool fRepeatLast)
  524. {
  525. CAutoLock cAutoLock(&m_csReceive);
  527. if((m_fb.flags&PIC_MASK_CODING_TYPE) == PIC_FLAG_CODING_TYPE_I)
  528. m_fWaitForKeyFrame = false;
  530. TCHAR frametype[] = {'?','I', 'P', 'B', 'D'};
  531. // TRACE(_T("%010I64d - %010I64d [%c] [prsq %d prfr %d tff %d rff %d nb_fields %d ref %d] (%dx%d/%dx%d)n"), 
  533. TRACE(_T("%010I64d - %010I64d [%c] [prsq %d prfr %d tff %d rff %d] (%dx%d %d) (preroll %d)n"), 
  534. m_fb.rtStart, m_fb.rtStop,
  535. frametype[m_fb.flags&PIC_MASK_CODING_TYPE],
  536. !!(m_dec->m_info.m_sequence->flags&SEQ_FLAG_PROGRESSIVE_SEQUENCE),
  537. !!(m_fb.flags&PIC_FLAG_PROGRESSIVE_FRAME),
  538. !!(m_fb.flags&PIC_FLAG_TOP_FIELD_FIRST),
  539. !!(m_fb.flags&PIC_FLAG_REPEAT_FIRST_FIELD),
  540. // m_dec->m_info.m_display_picture->nb_fields,
  541. // m_dec->m_info.m_display_picture->temporal_reference,
  542. m_fb.w, m_fb.h, m_fb.pitch,
  543. !!(m_fb.rtStart < 0 || m_fWaitForKeyFrame));
  544. /**/
  545. if(m_fb.rtStart < 0 || m_fWaitForKeyFrame)
  546. return S_OK;
  548. HRESULT hr;
  550. CComPtr<IMediaSample> pOut;
  551. BYTE* pDataOut = NULL;
  552. if(FAILED(hr = GetDeliveryBuffer(m_fb.w, m_fb.h, &pOut))
  553. || FAILED(hr = pOut->GetPointer(&pDataOut)))
  554. return hr;
  556. {
  557. CMpeg2DecInputPin* pPin = (CMpeg2DecInputPin*)m_pInput;
  558. CAutoLock cAutoLock(&pPin->m_csRateLock);
  559. if(m_rate.Rate != pPin->m_ratechange.Rate)
  560. {
  561. m_rate.Rate = pPin->m_ratechange.Rate;
  562. m_rate.StartTime = m_fb.rtStart;
  563. }
  564. }
  566. REFERENCE_TIME rtStart = m_fb.rtStart;
  567. REFERENCE_TIME rtStop = m_fb.rtStop;
  568. rtStart = m_rate.StartTime + (rtStart - m_rate.StartTime) * m_rate.Rate / 10000;
  569. rtStop = m_rate.StartTime + (rtStop - m_rate.StartTime) * m_rate.Rate / 10000;
  571. pOut->SetTime(&rtStart, &rtStop);
  572. pOut->SetMediaTime(NULL, NULL);
  574. if(m_fb.h == 1088)
  575. {
  576. memset(m_fb.buf[0] + m_fb.w*(m_fb.h-8), 0xff, m_fb.w*8);
  577. memset(m_fb.buf[1] + m_fb.w*(m_fb.h-8)/4, 0x80, m_fb.w*8/4);
  578. memset(m_fb.buf[2] + m_fb.w*(m_fb.h-8)/4, 0x80, m_fb.w*8/4);
  579. }
  581. BYTE** buf = &m_fb.buf[0];
  583. if(m_pSubpicInput->HasAnythingToRender(m_fb.rtStart))
  584. {
  585. BitBltFromI420ToI420(m_fb.w, m_fb.h, 
  586. m_fb.buf[3], m_fb.buf[4], m_fb.buf[5], m_fb.pitch, 
  587. m_fb.buf[0], m_fb.buf[1], m_fb.buf[2], m_fb.pitch);
  589. buf = &m_fb.buf[3];
  591. m_pSubpicInput->RenderSubpics(m_fb.rtStart, buf, m_fb.pitch, m_fb.h);
  592. }
  594. CopyBuffer(pDataOut, buf, (m_fb.w+7)&~7, m_fb.h, m_fb.pitch, MEDIASUBTYPE_I420);
  596. if(FAILED(hr = m_pOutput->Deliver(pOut)))
  597. return hr;
  599. return S_OK;
  600. }
  602. #include "........includeIFilterVersion.h"
  604. [uuid("04FE9017-F873-410E-871E-AB91661A4EF7")]
  605. struct ffdshow {};
  606. [uuid("93A22E7A-5091-45ef-BA61-6DA26156A5D0")]
  607. struct dvs {};
  608. [uuid("9852A670-F845-491b-9BE6-EBD841B8A613")]
  609. struct dvsauto {};
  610. [uuid("fd501043-8ebe-11ce-8183-00aa00577da1")]
  611. struct dladapter {};
  613. HRESULT CMpeg2DecFilter::CheckConnect(PIN_DIRECTION dir, IPin* pPin)
  614. {
  615. if(dir == PINDIR_OUTPUT)
  616. {
  617. if(GetCLSID(m_pInput->GetConnected()) == CLSID_DVDNavigator)
  618. {
  619. // one of these needed for dynamic format changes
  621. CLSID clsid = GetCLSID(pPin);
  623. DWORD ver = 0;
  624. if(CComQIPtr<IFilterVersion> pFV = GetFilterFromPin(pPin))
  625. ver = pFV->GetFilterVersion();
  627. if(clsid != CLSID_OverlayMixer
  628. /*&& clsid != CLSID_OverlayMixer2*/
  629. && clsid != CLSID_VideoMixingRenderer 
  630. && clsid != CLSID_VideoMixingRenderer9
  631. && clsid != __uuidof(ffdshow)
  632. && (clsid != __uuidof(dvs) || ver < 0x0234)
  633. && (clsid != __uuidof(dvsauto) || ver < 0x0234)
  634. && clsid != __uuidof(dladapter))
  635. return E_FAIL;
  636. }
  637. }
  639. return __super::CheckConnect(dir, pPin);
  640. }
  642. HRESULT CMpeg2DecFilter::CheckInputType(const CMediaType* mtIn)
  643. {
  644. if(mtIn->formattype == FORMAT_MPEG2_VIDEO && mtIn->pbFormat)
  645. {
  646. MPEG2VIDEOINFO* vih = (MPEG2VIDEOINFO*)mtIn->pbFormat;
  647. if(vih->cbSequenceHeader > 0 && (vih->dwSequenceHeader[0] & 0x00ffffff) != 0x00010000)
  648. return VFW_E_TYPE_NOT_ACCEPTED;
  649. }
  651. return (mtIn->majortype == MEDIATYPE_DVD_ENCRYPTED_PACK && mtIn->subtype == MEDIASUBTYPE_MPEG2_VIDEO
  652. || mtIn->majortype == MEDIATYPE_MPEG2_PACK && mtIn->subtype == MEDIASUBTYPE_MPEG2_VIDEO
  653. || mtIn->majortype == MEDIATYPE_MPEG2_PES && mtIn->subtype == MEDIASUBTYPE_MPEG2_VIDEO
  654. || mtIn->majortype == MEDIATYPE_Video && mtIn->subtype == MEDIASUBTYPE_MPEG2_VIDEO
  655. || mtIn->majortype == MEDIATYPE_Video && mtIn->subtype == MEDIASUBTYPE_MPEG1Packet
  656. || mtIn->majortype == MEDIATYPE_Video && mtIn->subtype == MEDIASUBTYPE_MPEG1Payload)
  657. ? S_OK
  658. : VFW_E_TYPE_NOT_ACCEPTED;
  659. }
  661. HRESULT CMpeg2DecFilter::CheckTransform(const CMediaType* mtIn, const CMediaType* mtOut)
  662. {
  663. bool fPlanarYUV = mtOut->subtype == MEDIASUBTYPE_YV12 || mtOut->subtype == MEDIASUBTYPE_I420 || mtOut->subtype == MEDIASUBTYPE_IYUV;
  665. return SUCCEEDED(__super::CheckTransform(mtIn, mtOut))
  666. && (!fPlanarYUV || IsPlanarYUVEnabled())
  667. ? S_OK
  668. : VFW_E_TYPE_NOT_ACCEPTED;
  669. }
  671. HRESULT CMpeg2DecFilter::StartStreaming()
  672. {
  673. HRESULT hr = __super::StartStreaming();
  674. if(FAILED(hr)) return hr;
  676. m_dec.Attach(new CMpeg2Dec());
  677. if(!m_dec) return E_OUTOFMEMORY;
  679. InputTypeChanged();
  681. return S_OK;
  682. }
  684. HRESULT CMpeg2DecFilter::StopStreaming()
  685. {
  686. m_dec.Free();
  688. return __super::StopStreaming();
  689. }
  691. HRESULT CMpeg2DecFilter::AlterQuality(Quality q)
  692. {
  693. if(q.Late > 500*10000i64) m_fDropFrames = true;
  694. else if(q.Late <= 0) m_fDropFrames = false;
  696. // TRACE(_T("CMpeg2DecFilter::AlterQuality: Type=%d, Proportion=%d, Late=%I64d, TimeStamp=%I64dn"), q.Type, q.Proportion, q.Late, q.TimeStamp);
  697. return S_OK;
  698. }
  700. // IMpeg2DecFilter
  702. STDMETHODIMP CMpeg2DecFilter::SetDeinterlaceMethod(ditype di)
  703. {
  704. CAutoLock cAutoLock(&m_csProps);
  705. m_di = di;
  706. return S_OK;
  707. }
  709. STDMETHODIMP_(ditype) CMpeg2DecFilter::GetDeinterlaceMethod()
  710. {
  711. CAutoLock cAutoLock(&m_csProps);
  712. return m_di;
  713. }
  715. void CMpeg2DecFilter::CalcBrCont(BYTE* YTbl, double bright, double cont)
  716. {
  717. int Cont = (int)(cont * 512);
  718. int Bright = (int)bright;
  720. for(int i = 0; i < 256; i++)
  721. {
  722. int y = ((Cont * (i - 16)) >> 9) + Bright + 16;
  723. YTbl[i] = min(max(y, 0), 255);
  724. // YTbl[i] = min(max(y, 16), 235);
  725. }
  726. }
  728. void CMpeg2DecFilter::CalcHueSat(BYTE* UTbl, BYTE* VTbl, double hue, double sat)
  729. {
  730. int Sat = (int)(sat * 512);
  731. double Hue = (hue * 3.1415926) / 180.0;
  732. int Sin = (int)(sin(Hue) * 4096);
  733. int Cos = (int)(cos(Hue) * 4096);
  735. for(int y = 0; y < 256; y++)
  736. {
  737. for(int x = 0; x < 256; x++)
  738. {
  739. int u = x - 128; 
  740. int v = y - 128;
  741. int ux = (u * Cos + v * Sin) >> 12;
  742. v = (v * Cos - u * Sin) >> 12;
  743. u = ((ux * Sat) >> 9) + 128;
  744. v = ((v * Sat) >> 9) + 128;
  745. u = min(max(u, 16), 235);
  746. v = min(max(v, 16), 235);
  747. UTbl[(y << 8) | x] = u;
  748. VTbl[(y << 8) | x] = v;
  749. }
  750. }
  751. }
  753. void CMpeg2DecFilter::ApplyBrContHueSat(BYTE* srcy, BYTE* srcu, BYTE* srcv, int w, int h, int pitch)
  754. {
  755. CAutoLock cAutoLock(&m_csProps);
  757. double EPSILON = 1e-4;
  759. if(fabs(m_bright-0.0) > EPSILON || fabs(m_cont-1.0) > EPSILON)
  760. {
  761. for(int size = pitch*h; size > 0; size--)
  762. {
  763. *srcy++ = m_YTbl[*srcy];
  764. }
  765. }
  767. pitch /= 2;
  768. w /= 2;
  769. h /= 2;
  771. if(fabs(m_hue-0.0) > EPSILON || fabs(m_sat-1.0) > EPSILON)
  772. {
  773. for(int size = pitch*h; size > 0; size--)
  774. {
  775. WORD uv = (*srcv<<8)|*srcu;
  776. *srcu++ = m_UTbl[uv];
  777. *srcv++ = m_VTbl[uv];
  778. }
  779. }
  780. }
  782. STDMETHODIMP CMpeg2DecFilter::SetBrightness(double bright)
  783. {
  784. CAutoLock cAutoLock(&m_csProps);
  785. CalcBrCont(m_YTbl, m_bright = bright, m_cont);
  786. return S_OK;
  787. }
  789. STDMETHODIMP CMpeg2DecFilter::SetContrast(double cont)
  790. {
  791. CAutoLock cAutoLock(&m_csProps);
  792. CalcBrCont(m_YTbl, m_bright, m_cont = cont);
  793. return S_OK;
  794. }
  796. STDMETHODIMP CMpeg2DecFilter::SetHue(double hue)
  797. {
  798. CAutoLock cAutoLock(&m_csProps);
  799. CalcHueSat(m_UTbl, m_VTbl, m_hue = hue, m_sat);
  800. return S_OK;
  801. }
  803. STDMETHODIMP CMpeg2DecFilter::SetSaturation(double sat)
  804. {
  805. CAutoLock cAutoLock(&m_csProps);
  806. CalcHueSat(m_UTbl, m_VTbl, m_hue, m_sat = sat);
  807. return S_OK;
  808. }
  810. STDMETHODIMP_(double) CMpeg2DecFilter::GetBrightness()
  811. {
  812. CAutoLock cAutoLock(&m_csProps);
  813. return m_bright;
  814. }
  816. STDMETHODIMP_(double) CMpeg2DecFilter::GetContrast()
  817. {
  818. CAutoLock cAutoLock(&m_csProps);
  819. return m_cont;
  820. }
  822. STDMETHODIMP_(double) CMpeg2DecFilter::GetHue()
  823. {
  824. CAutoLock cAutoLock(&m_csProps);
  825. return m_hue;
  826. }
  828. STDMETHODIMP_(double) CMpeg2DecFilter::GetSaturation()
  829. {
  830. CAutoLock cAutoLock(&m_csProps);
  831. return m_sat;
  832. }
  834. STDMETHODIMP CMpeg2DecFilter::EnableForcedSubtitles(bool fEnable)
  835. {
  836. CAutoLock cAutoLock(&m_csProps);
  837. m_fForcedSubs = fEnable;
  838. return S_OK;
  839. }
  841. STDMETHODIMP_(bool) CMpeg2DecFilter::IsForcedSubtitlesEnabled()
  842. {
  843. CAutoLock cAutoLock(&m_csProps);
  844. return m_fForcedSubs;
  845. }
  847. STDMETHODIMP CMpeg2DecFilter::EnablePlanarYUV(bool fEnable)
  848. {
  849. CAutoLock cAutoLock(&m_csProps);
  850. m_fPlanarYUV = fEnable;
  851. return S_OK;
  852. }
  854. STDMETHODIMP_(bool) CMpeg2DecFilter::IsPlanarYUVEnabled()
  855. {
  856. CAutoLock cAutoLock(&m_csProps);
  857. return m_fPlanarYUV;
  858. }
  860. //
  861. // CMpeg2DecInputPin
  862. //
  864. CMpeg2DecInputPin::CMpeg2DecInputPin(CTransformFilter* pFilter, HRESULT* phr, LPWSTR pName)
  865. : CDeCSSInputPin(NAME("CMpeg2DecInputPin"), pFilter, phr, pName)
  866. {
  867. m_CorrectTS = 0;
  868. m_ratechange.Rate = 10000;
  869. m_ratechange.StartTime = _I64_MAX;
  870. }
  872. // IKsPropertySet
  874. STDMETHODIMP CMpeg2DecInputPin::Set(REFGUID PropSet, ULONG Id, LPVOID pInstanceData, ULONG InstanceLength, LPVOID pPropertyData, ULONG DataLength)
  875. {
  876. if(PropSet != AM_KSPROPSETID_TSRateChange /*&& PropSet != AM_KSPROPSETID_DVD_RateChange*/)
  877. return __super::Set(PropSet, Id, pInstanceData, InstanceLength, pPropertyData, DataLength);
  879. if(PropSet == AM_KSPROPSETID_TSRateChange)
  880. switch(Id)
  881. {
  882. case AM_RATE_SimpleRateChange:
  883. {
  884. AM_SimpleRateChange* p = (AM_SimpleRateChange*)pPropertyData;
  885. if(!m_CorrectTS) return E_PROP_ID_UNSUPPORTED;
  886. CAutoLock cAutoLock(&m_csRateLock);
  887. m_ratechange = *p;
  888. DbgLog((LOG_TRACE, 0, _T("StartTime=%I64d, Rate=%d"), p->StartTime, p->Rate));
  889. }
  890. break;
  891. case AM_RATE_UseRateVersion:
  892. {
  893. WORD* p = (WORD*)pPropertyData;
  894. if(*p > 0x0101) return E_PROP_ID_UNSUPPORTED;
  895. }
  896. break;
  897. case AM_RATE_CorrectTS:
  898. {
  899. LONG* p = (LONG*)pPropertyData;
  900. m_CorrectTS = *p;
  901. }
  902. break;
  903. default:
  904. return E_PROP_ID_UNSUPPORTED;
  905. }
  906. /*
  907. if(PropSet == AM_KSPROPSETID_DVD_RateChange)
  908. switch(Id)
  909. {
  910. case AM_RATE_ChangeRate:
  911. {
  912. AM_DVD_ChangeRate* p = (AM_DVD_ChangeRate*)pPropertyData;
  913. }
  914. break;
  915. default:
  916. return E_PROP_ID_UNSUPPORTED;
  917. }
  918. */
  919. return S_OK;
  920. }
  922. STDMETHODIMP CMpeg2DecInputPin::Get(REFGUID PropSet, ULONG Id, LPVOID pInstanceData, ULONG InstanceLength, LPVOID pPropertyData, ULONG DataLength, ULONG* pBytesReturned)
  923. {
  924. if(PropSet != AM_KSPROPSETID_TSRateChange /*&& PropSet != AM_KSPROPSETID_DVD_RateChange*/)
  925. return __super::Get(PropSet, Id, pInstanceData, InstanceLength, pPropertyData, DataLength, pBytesReturned);
  927. if(PropSet == AM_KSPROPSETID_TSRateChange)
  928. switch(Id)
  929. {
  930. case AM_RATE_SimpleRateChange:
  931. {
  932. AM_SimpleRateChange* p = (AM_SimpleRateChange*)pPropertyData;
  933. return E_PROP_ID_UNSUPPORTED;
  934. }
  935. break;
  936. case AM_RATE_MaxFullDataRate:
  937. {
  938. AM_MaxFullDataRate* p = (AM_MaxFullDataRate*)pPropertyData;
  939. *p = 8*10000;
  940. *pBytesReturned = sizeof(AM_MaxFullDataRate);
  941. }
  942. break;
  943. case AM_RATE_QueryFullFrameRate:
  944. {
  945. AM_QueryRate* p = (AM_QueryRate*)pPropertyData;
  946. p->lMaxForwardFullFrame = 8*10000;
  947. p->lMaxReverseFullFrame = 8*10000;
  948. *pBytesReturned = sizeof(AM_QueryRate);
  949. }
  950. break;
  951. case AM_RATE_QueryLastRateSegPTS:
  952. {
  953. REFERENCE_TIME* p = (REFERENCE_TIME*)pPropertyData;
  954. return E_PROP_ID_UNSUPPORTED;
  955. }
  956. break;
  957. default:
  958. return E_PROP_ID_UNSUPPORTED;
  959. }
  960. /*
  961. if(PropSet == AM_KSPROPSETID_DVD_RateChange)
  962. switch(Id)
  963. {
  964. case AM_RATE_FullDataRateMax:
  965. {
  966. AM_MaxFullDataRate* p = (AM_MaxFullDataRate*)pPropertyData;
  967. }
  968. break;
  969. case AM_RATE_ReverseDecode:
  970. {
  971. LONG* p = (LONG*)pPropertyData;
  972. }
  973. break;
  974. case AM_RATE_DecoderPosition:
  975. {
  976. AM_DVD_DecoderPosition* p = (AM_DVD_DecoderPosition*)pPropertyData;
  977. }
  978. break;
  979. case AM_RATE_DecoderVersion:
  980. {
  981. LONG* p = (LONG*)pPropertyData;
  982. }
  983. break;
  984. default:
  985. return E_PROP_ID_UNSUPPORTED;
  986. }
  987. */
  988. return S_OK;
  989. }
  991. STDMETHODIMP CMpeg2DecInputPin::QuerySupported(REFGUID PropSet, ULONG Id, ULONG* pTypeSupport)
  992. {
  993. if(PropSet != AM_KSPROPSETID_TSRateChange /*&& PropSet != AM_KSPROPSETID_DVD_RateChange*/)
  994. return __super::QuerySupported(PropSet, Id, pTypeSupport);
  996. if(PropSet == AM_KSPROPSETID_TSRateChange)
  997. switch(Id)
  998. {
  999. case AM_RATE_SimpleRateChange:
  1000. *pTypeSupport = KSPROPERTY_SUPPORT_GET | KSPROPERTY_SUPPORT_SET;
  1001. break;
  1002. case AM_RATE_MaxFullDataRate:
  1003. *pTypeSupport = KSPROPERTY_SUPPORT_GET;
  1004. break;
  1005. case AM_RATE_UseRateVersion:
  1006. *pTypeSupport = KSPROPERTY_SUPPORT_SET;
  1007. break;
  1008. case AM_RATE_QueryFullFrameRate:
  1009. *pTypeSupport = KSPROPERTY_SUPPORT_GET;
  1010. break;
  1011. case AM_RATE_QueryLastRateSegPTS:
  1012. *pTypeSupport = KSPROPERTY_SUPPORT_GET;
  1013. break;
  1014. case AM_RATE_CorrectTS:
  1015. *pTypeSupport = KSPROPERTY_SUPPORT_SET;
  1016. break;
  1017. default:
  1018. return E_PROP_ID_UNSUPPORTED;
  1019. }
  1020. /*
  1021. if(PropSet == AM_KSPROPSETID_DVD_RateChange)
  1022. switch(Id)
  1023. {
  1024. case AM_RATE_ChangeRate:
  1025. *pTypeSupport = KSPROPERTY_SUPPORT_SET;
  1026. break;
  1027. case AM_RATE_FullDataRateMax:
  1028. *pTypeSupport = KSPROPERTY_SUPPORT_GET;
  1029. break;
  1030. case AM_RATE_ReverseDecode:
  1031. *pTypeSupport = KSPROPERTY_SUPPORT_GET;
  1032. break;
  1033. case AM_RATE_DecoderPosition:
  1034. *pTypeSupport = KSPROPERTY_SUPPORT_GET;
  1035. break;
  1036. case AM_RATE_DecoderVersion:
  1037. *pTypeSupport = KSPROPERTY_SUPPORT_GET;
  1038. break;
  1039. default:
  1040. return E_PROP_ID_UNSUPPORTED;
  1041. }
  1042. */
  1043. return S_OK;
  1044. }
  1046. //
  1047. // CSubpicInputPin
  1048. //
  1050. #define PTS2RT(pts) (10000i64*pts/90)
  1052. CSubpicInputPin::CSubpicInputPin(CTransformFilter* pFilter, HRESULT* phr) 
  1053. : CMpeg2DecInputPin(pFilter, phr, L"SubPicture")
  1054. , m_spon(TRUE)
  1055. , m_fsppal(false)
  1056. {
  1057. m_sppal[0].Y = 0x00;
  1058. m_sppal[0].U = m_sppal[0].V = 0x80;
  1059. m_sppal[1].Y = 0xe0;
  1060. m_sppal[1].U = m_sppal[1].V = 0x80;
  1061. m_sppal[2].Y = 0x80;
  1062. m_sppal[2].U = m_sppal[2].V = 0x80;
  1063. m_sppal[3].Y = 0x20;
  1064. m_sppal[3].U = m_sppal[3].V = 0x80;
  1065. }
  1067. HRESULT CSubpicInputPin::CheckMediaType(const CMediaType* mtIn)
  1068. {
  1069. return (mtIn->majortype == MEDIATYPE_DVD_ENCRYPTED_PACK
  1070. || mtIn->majortype == MEDIATYPE_MPEG2_PACK
  1071. || mtIn->majortype == MEDIATYPE_MPEG2_PES
  1072. || mtIn->majortype == MEDIATYPE_Video) 
  1073. && (mtIn->subtype == MEDIASUBTYPE_DVD_SUBPICTURE
  1074. || mtIn->subtype == MEDIASUBTYPE_CVD_SUBPICTURE
  1075. || mtIn->subtype == MEDIASUBTYPE_SVCD_SUBPICTURE)
  1076. ? S_OK
  1077. : VFW_E_TYPE_NOT_ACCEPTED;
  1078. }
  1080. HRESULT CSubpicInputPin::SetMediaType(const CMediaType* mtIn)
  1081. {
  1082. return CBasePin::SetMediaType(mtIn);
  1083. }
  1085. bool CSubpicInputPin::HasAnythingToRender(REFERENCE_TIME rt)
  1086. {
  1087. if(!IsConnected()) return(false);
  1089. CAutoLock cAutoLock(&m_csReceive);
  1091. POSITION pos = m_sps.GetHeadPosition();
  1092. while(pos)
  1093. {
  1094. spu* sp = m_sps.GetNext(pos);
  1095. if(sp->m_rtStart <= rt && rt < sp->m_rtStop && (/*sp->m_psphli ||*/ sp->m_fForced || m_spon))
  1096. return(true);
  1097. }
  1099. return(false);
  1100. }
  1102. void CSubpicInputPin::RenderSubpics(REFERENCE_TIME rt, BYTE** yuv, int w, int h)
  1103. {
  1104. CAutoLock cAutoLock(&m_csReceive);
  1106. POSITION pos;
  1108. // remove no longer needed things first
  1109. pos = m_sps.GetHeadPosition();
  1110. while(pos)
  1111. {
  1112. POSITION cur = pos;
  1113. spu* sp = m_sps.GetNext(pos);
  1114. if(sp->m_rtStop <= rt) m_sps.RemoveAt(cur);
  1115. }
  1117. pos = m_sps.GetHeadPosition();
  1118. while(pos)
  1119. {
  1120. spu* sp = m_sps.GetNext(pos);
  1121. if(sp->m_rtStart <= rt && rt < sp->m_rtStop 
  1122. && (m_spon || sp->m_fForced && (((CMpeg2DecFilter*)m_pFilter)->IsForcedSubtitlesEnabled() || sp->m_psphli)))
  1123. sp->Render(yuv, w, h, m_sppal, m_fsppal);
  1124. }
  1125. }
  1127. HRESULT CSubpicInputPin::Transform(IMediaSample* pSample)
  1128. {
  1129. HRESULT hr;
  1131. AM_MEDIA_TYPE* pmt;
  1132. if(SUCCEEDED(pSample->GetMediaType(&pmt)) && pmt)
  1133. {
  1134. CMediaType mt(*pmt);
  1135. SetMediaType(&mt);
  1136. DeleteMediaType(pmt);
  1137. }
  1139. BYTE* pDataIn = NULL;
  1140. if(FAILED(hr = pSample->GetPointer(&pDataIn))) return hr;
  1142. long len = pSample->GetActualDataLength();
  1144. StripPacket(pDataIn, len);
  1146. if(len <= 0) return S_FALSE;
  1148. if(m_mt.subtype == MEDIASUBTYPE_SVCD_SUBPICTURE)
  1149. {
  1150. pDataIn += 4;
  1151. len -= 4;
  1152. }
  1154. if(len <= 0) return S_FALSE;
  1156. CAutoLock cAutoLock(&m_csReceive);
  1158. REFERENCE_TIME rtStart = 0, rtStop = 0;
  1159. hr = pSample->GetTime(&rtStart, &rtStop);
  1161. bool fRefresh = false;
  1163. if(FAILED(hr))
  1164. {
  1165. if(!m_sps.IsEmpty())
  1166. {
  1167. spu* sp = m_sps.GetTail();
  1168. sp->m_pData.SetSize(sp->m_pData.GetSize() + len);
  1169. memcpy(sp->m_pData.GetData() + sp->m_pData.GetSize() - len, pDataIn, len);
  1170. }
  1171. }
  1172. else
  1173. {
  1174. POSITION pos = m_sps.GetTailPosition();
  1175. while(pos)
  1176. {
  1177. POSITION cur = pos;
  1178. spu* sp = m_sps.GetPrev(pos);
  1179. if(sp->m_rtStop == _I64_MAX)
  1180. {
  1181. sp->m_rtStop = rtStart;
  1182. break;
  1183. }
  1184. }
  1186. CAutoPtr<spu> p;
  1188. if(m_mt.subtype == MEDIASUBTYPE_DVD_SUBPICTURE) p.Attach(new dvdspu());
  1189. else if(m_mt.subtype == MEDIASUBTYPE_CVD_SUBPICTURE) p.Attach(new cvdspu());
  1190. else if(m_mt.subtype == MEDIASUBTYPE_SVCD_SUBPICTURE) p.Attach(new svcdspu());
  1191. else return E_FAIL;
  1193. p->m_rtStart = rtStart;
  1194. p->m_rtStop = _I64_MAX;
  1196. p->m_pData.SetSize(len);
  1197. memcpy(p->m_pData.GetData(), pDataIn, len);
  1199. if(m_sphli && p->m_rtStart == PTS2RT(m_sphli->StartPTM))
  1200. {
  1201. p->m_psphli = m_sphli;
  1202. fRefresh = true;
  1203. }
  1205. m_sps.AddTail(p);
  1206. }
  1208. if(!m_sps.IsEmpty())
  1209. {
  1210. m_sps.GetTail()->Parse();
  1211. }
  1213. if(fRefresh)
  1214. {
  1215. // ((CMpeg2DecFilter*)m_pFilter)->Deliver(true);
  1216. }
  1218. return S_FALSE;
  1219. }
  1221. STDMETHODIMP CSubpicInputPin::EndFlush()
  1222. {
  1223. CAutoLock cAutoLock(&m_csReceive);
  1224. m_sps.RemoveAll();
  1225. return S_OK;
  1226. }
  1228. // IKsPropertySet
  1230. STDMETHODIMP CSubpicInputPin::Set(REFGUID PropSet, ULONG Id, LPVOID pInstanceData, ULONG InstanceLength, LPVOID pPropertyData, ULONG DataLength)
  1231. {
  1232. if(PropSet != AM_KSPROPSETID_DvdSubPic)
  1233. return __super::Set(PropSet, Id, pInstanceData, InstanceLength, pPropertyData, DataLength);
  1235. bool fRefresh = false;
  1237. switch(Id)
  1238. {
  1239. case AM_PROPERTY_DVDSUBPIC_PALETTE:
  1240. {
  1241. CAutoLock cAutoLock(&m_csReceive);
  1242. AM_PROPERTY_SPPAL* pSPPAL = (AM_PROPERTY_SPPAL*)pPropertyData;
  1243. memcpy(m_sppal, pSPPAL->sppal, sizeof(AM_PROPERTY_SPPAL));
  1244. m_fsppal = true;
  1246. DbgLog((LOG_TRACE, 0, _T("new palette")));
  1247. }
  1248. break;
  1249. case AM_PROPERTY_DVDSUBPIC_HLI:
  1250. {
  1251. CAutoLock cAutoLock(&m_csReceive);
  1253. AM_PROPERTY_SPHLI* pSPHLI = (AM_PROPERTY_SPHLI*)pPropertyData;
  1255. m_sphli.Free();
  1257. if(pSPHLI->HLISS)
  1258. {
  1259. POSITION pos = m_sps.GetHeadPosition();
  1260. while(pos)
  1261. {
  1262. spu* sp = m_sps.GetNext(pos);
  1263. if(sp->m_rtStart <= PTS2RT(pSPHLI->StartPTM) && PTS2RT(pSPHLI->StartPTM) < sp->m_rtStop)
  1264. {
  1265. fRefresh = true;
  1266. sp->m_psphli.Free();
  1267. sp->m_psphli.Attach(new AM_PROPERTY_SPHLI());
  1268. memcpy((AM_PROPERTY_SPHLI*)sp->m_psphli, pSPHLI, sizeof(AM_PROPERTY_SPHLI));
  1269. }
  1270. }
  1272. if(!fRefresh) // save it for later, a subpic might be late for this hli
  1273. {
  1274. m_sphli.Attach(new AM_PROPERTY_SPHLI());
  1275. memcpy((AM_PROPERTY_SPHLI*)m_sphli, pSPHLI, sizeof(AM_PROPERTY_SPHLI));
  1276. }
  1277. }
  1278. else
  1279. {
  1280. POSITION pos = m_sps.GetHeadPosition();
  1281. while(pos)
  1282. {
  1283. spu* sp = m_sps.GetNext(pos);
  1284. fRefresh |= !!sp->m_psphli;
  1285. sp->m_psphli.Free();
  1286. }
  1287. }
  1289. if(pSPHLI->HLISS)
  1290. DbgLog((LOG_TRACE, 0, _T("hli: %I64d - %I64d, (%d,%d) - (%d,%d)"), 
  1291. PTS2RT(pSPHLI->StartPTM)/10000, PTS2RT(pSPHLI->EndPTM)/10000,
  1292. pSPHLI->StartX, pSPHLI->StartY, pSPHLI->StopX, pSPHLI->StopY));
  1293. }
  1294. break;
  1295. case AM_PROPERTY_DVDSUBPIC_COMPOSIT_ON:
  1296. {
  1297. CAutoLock cAutoLock(&m_csReceive);
  1298. AM_PROPERTY_COMPOSIT_ON* pCompositOn = (AM_PROPERTY_COMPOSIT_ON*)pPropertyData;
  1299. m_spon = *pCompositOn;
  1300. }
  1301. break;
  1302. default:
  1303. return E_PROP_ID_UNSUPPORTED;
  1304. }
  1306. if(fRefresh)
  1307. {
  1308. ((CMpeg2DecFilter*)m_pFilter)->Deliver(true);
  1309. }
  1311. return S_OK;
  1312. }
  1314. STDMETHODIMP CSubpicInputPin::QuerySupported(REFGUID PropSet, ULONG Id, ULONG* pTypeSupport)
  1315. {
  1316. if(PropSet != AM_KSPROPSETID_DvdSubPic)
  1317. return __super::QuerySupported(PropSet, Id, pTypeSupport);
  1319. switch(Id)
  1320. {
  1321. case AM_PROPERTY_DVDSUBPIC_PALETTE:
  1322. *pTypeSupport = KSPROPERTY_SUPPORT_SET;
  1323. break;
  1324. case AM_PROPERTY_DVDSUBPIC_HLI:
  1325. *pTypeSupport = KSPROPERTY_SUPPORT_SET;
  1326. break;
  1327. case AM_PROPERTY_DVDSUBPIC_COMPOSIT_ON:
  1328. *pTypeSupport = KSPROPERTY_SUPPORT_SET;
  1329. break;
  1330. default:
  1331. return E_PROP_ID_UNSUPPORTED;
  1332. }
  1334. return S_OK;
  1335. }
  1337. // CSubpicInputPin::spu
  1339. static __inline BYTE GetNibble(BYTE* p, DWORD* offset, int& nField, int& fAligned)
  1340. {
  1341. BYTE ret = (p[offset[nField]] >> (fAligned << 2)) & 0x0f;
  1342. offset[nField] += 1-fAligned;
  1343. fAligned = !fAligned;
  1344.     return ret;
  1345. }
  1347. static __inline BYTE GetHalfNibble(BYTE* p, DWORD* offset, int& nField, int& n)
  1348. {
  1349. BYTE ret = (p[offset[nField]] >> (n << 1)) & 0x03;
  1350. if(!n) offset[nField]++;
  1351. n = (n-1+4)&3;
  1352.     return ret;
  1353. }
  1355. static __inline void DrawPixel(BYTE** yuv, CPoint pt, int pitch, AM_DVD_YUV& c)
  1356. {
  1357. if(c.Reserved == 0) return;
  1359. BYTE* p = &yuv[0][pt.y*pitch + pt.x];
  1360. // *p = (*p*(15-contrast) + sppal[color].Y*contrast)>>4;
  1361. *p -= (*p - c.Y) * c.Reserved >> 4;
  1363. if(pt.y&1) return; // since U/V is half res there is no need to overwrite the same line again
  1365. pt.x = (pt.x + 1) / 2;
  1366. pt.y = (pt.y /*+ 1*/) / 2; // only paint the upper field always, don't round it
  1367. pitch /= 2;
  1369. // U/V is exchanged? wierd but looks true when comparing the outputted colors from other decoders
  1371. p = &yuv[1][pt.y*pitch + pt.x];
  1372. // *p = (BYTE)(((((int)*p-0x80)*(15-contrast) + ((int)sppal[color].V-0x80)*contrast) >> 4) + 0x80);
  1373. *p -= (*p - c.V) * c.Reserved >> 4;
  1375. p = &yuv[2][pt.y*pitch + pt.x];
  1376. // *p = (BYTE)(((((int)*p-0x80)*(15-contrast) + ((int)sppal[color].U-0x80)*contrast) >> 4) + 0x80);
  1377. *p -= (*p - c.U) * c.Reserved >> 4;
  1379. // Neighter of the blending formulas are accurate (">>4" should be "/15").
  1380. // Even though the second one is a bit worse, since we are scaling the difference only,
  1381. // the error is still not noticable.
  1382. }
  1384. static __inline void DrawPixels(BYTE** yuv, int pitch, CPoint pt, int len, AM_DVD_YUV& c, CRect& rc)
  1385. {
  1386.     if(pt.y < rc.top || pt.y >= rc.bottom) return;
  1387. if(pt.x < rc.left) {len -= rc.left - pt.x; pt.x = rc.left;}
  1388. if(pt.x + len > rc.right) len = rc.right - pt.x;
  1389. if(len <= 0 || pt.x >= rc.right) return;
  1391. if(c.Reserved == 0)
  1392. {
  1393. if(rc.IsRectEmpty())
  1394. return;
  1396. if(pt.y < rc.top || pt.y >= rc.bottom 
  1397. || pt.x+len < rc.left || pt.x >= rc.right)
  1398. return;
  1399. }
  1401. while(len-- > 0)
  1402. {
  1403. DrawPixel(yuv, pt, pitch, c);
  1404. pt.x++;
  1405. }
  1406. }
  1408. // CSubpicInputPin::dvdspu
  1410. bool CSubpicInputPin::dvdspu::Parse()
  1411. {
  1412. BYTE* p = m_pData.GetData();
  1414. WORD packetsize = (p[0]<<8)|p[1];
  1415. WORD datasize = (p[2]<<8)|p[3];
  1417.     if(packetsize > m_pData.GetSize() || datasize > packetsize)
  1418. return(false);
  1420. int i, next = datasize;
  1422. #define GetWORD (p[i]<<8)|p[i+1]; i += 2
  1424. do
  1425. {
  1426. i = next;
  1428. int pts = GetWORD;
  1429. next = GetWORD;
  1431. if(next > packetsize || next < datasize)
  1432. return(false);
  1434. for(bool fBreak = false; !fBreak; )
  1435. {
  1436. int len = 0;
  1438. switch(p[i])
  1439. {
  1440. case 0x00: len = 0; break;
  1441. case 0x01: len = 0; break;
  1442. case 0x02: len = 0; break;
  1443. case 0x03: len = 2; break;
  1444. case 0x04: len = 2; break;
  1445. case 0x05: len = 6; break;
  1446. case 0x06: len = 4; break;
  1447. default: len = 0; break;
  1448. }
  1450. if(i+len >= packetsize)
  1451. {
  1452. TRACE(_T("Warning: Wrong subpicture parameter block endingn"));
  1453. break;
  1454. }
  1456. switch(p[i++])
  1457. {
  1458. case 0x00: // forced start displaying
  1459. m_fForced = true;
  1460. break;
  1461. case 0x01: // normal start displaying
  1462. m_fForced = false;
  1463. break;
  1464. case 0x02: // stop displaying
  1465. m_rtStop = m_rtStart + 1024*PTS2RT(pts);
  1466. break;
  1467. case 0x03:
  1468. m_sphli.ColCon.emph2col = p[i]>>4;
  1469. m_sphli.ColCon.emph1col = p[i]&0xf;
  1470. m_sphli.ColCon.patcol = p[i+1]>>4;
  1471. m_sphli.ColCon.backcol = p[i+1]&0xf;
  1472. i += 2;
  1473. break;
  1474. case 0x04:
  1475. m_sphli.ColCon.emph2con = p[i]>>4;
  1476. m_sphli.ColCon.emph1con = p[i]&0xf;
  1477. m_sphli.ColCon.patcon = p[i+1]>>4;
  1478. m_sphli.ColCon.backcon = p[i+1]&0xf;
  1479. i += 2;
  1480. break;
  1481. case 0x05:
  1482. m_sphli.StartX = (p[i]<<4) + (p[i+1]>>4);
  1483. m_sphli.StopX = ((p[i+1]&0x0f)<<8) + p[i+2]+1;
  1484. m_sphli.StartY = (p[i+3]<<4) + (p[i+4]>>4);
  1485. m_sphli.StopY = ((p[i+4]&0x0f)<<8) + p[i+5]+1;
  1486. i += 6;
  1487. break;
  1488. case 0x06:
  1489. m_offset[0] = GetWORD;
  1490. m_offset[1] = GetWORD;
  1491. break;
  1492. case 0xff: // end of ctrlblk
  1493. fBreak = true;
  1494. continue;
  1495. default: // skip this ctrlblk
  1496. fBreak = true;
  1497. break;
  1498. }
  1499. }
  1500. }
  1501. while(i <= next && i < packetsize);
  1503. return(true);
  1504. }
  1506. void CSubpicInputPin::dvdspu::Render(BYTE** yuv, int w, int h, AM_DVD_YUV* sppal, bool fsppal)
  1507. {
  1508. BYTE* p = m_pData.GetData();
  1509. DWORD offset[2] = {m_offset[0], m_offset[1]};
  1511. AM_PROPERTY_SPHLI sphli = m_sphli;
  1512. CPoint pt(sphli.StartX, sphli.StartY);
  1513. CRect rc(pt, CPoint(sphli.StopX, sphli.StopY));
  1515. CRect rcclip(0, 0, w, h);
  1516. rcclip &= rc;
  1518. if(m_psphli)
  1519. {
  1520. rcclip &= CRect(m_psphli->StartX, m_psphli->StartY, m_psphli->StopX, m_psphli->StopY);
  1521. sphli = *m_psphli;
  1522. }
  1524. AM_DVD_YUV pal[4];
  1525. pal[0] = sppal[fsppal ? sphli.ColCon.backcol : 0];
  1526. pal[0].Reserved = sphli.ColCon.backcon;
  1527. pal[1] = sppal[fsppal ? sphli.ColCon.patcol : 1];
  1528. pal[1].Reserved = sphli.ColCon.patcon;
  1529. pal[2] = sppal[fsppal ? sphli.ColCon.emph1col : 2];
  1530. pal[2].Reserved = sphli.ColCon.emph1con;
  1531. pal[3] = sppal[fsppal ? sphli.ColCon.emph2col : 3];
  1532. pal[3].Reserved = sphli.ColCon.emph2con;
  1534. int nField = 0;
  1535. int fAligned = 1;
  1537. DWORD end[2] = {offset[1], (p[2]<<8)|p[3]};
  1539. while((nField == 0 && offset[0] < end[0]) || (nField == 1 && offset[1] < end[1]))
  1540. {
  1541. DWORD code;
  1543. if((code = GetNibble(p, offset, nField, fAligned)) >= 0x4
  1544. || (code = (code << 4) | GetNibble(p, offset, nField, fAligned)) >= 0x10
  1545. || (code = (code << 4) | GetNibble(p, offset, nField, fAligned)) >= 0x40
  1546. || (code = (code << 4) | GetNibble(p, offset, nField, fAligned)) >= 0x100)
  1547. {
  1548. DrawPixels(yuv, w, pt, code >> 2, pal[code&3], rcclip);
  1549. if((pt.x += code >> 2) < rc.right) continue;
  1550. }
  1552. DrawPixels(yuv, w, pt, rc.right - pt.x, pal[code&3], rcclip);
  1554. if(!fAligned) GetNibble(p, offset, nField, fAligned); // align to byte
  1556. pt.x = rc.left;
  1557. pt.y++;
  1558. nField = 1 - nField;
  1559. }
  1560. }
  1562. // CSubpicInputPin::cvdspu
  1564. bool CSubpicInputPin::cvdspu::Parse()
  1565. {
  1566. BYTE* p = m_pData.GetData();
  1568. WORD packetsize = (p[0]<<8)|p[1];
  1569. WORD datasize = (p[2]<<8)|p[3];
  1571.     if(packetsize > m_pData.GetSize() || datasize > packetsize)
  1572. return(false);
  1574. p = m_pData.GetData() + datasize;
  1576. for(int i = datasize, j = packetsize-4; i <= j; i+=4, p+=4)
  1577. {
  1578. switch(p[0])
  1579. {
  1580. case 0x0c: 
  1581. break;
  1582. case 0x04: 
  1583. m_rtStop = m_rtStart + 10000i64*((p[1]<<16)|(p[2]<<8)|p[3])/90;
  1584. break;
  1585. case 0x17: 
  1586. m_sphli.StartX = ((p[1]&0x0f)<<6) + (p[2]>>2);
  1587. m_sphli.StartY = ((p[2]&0x03)<<8) + p[3];
  1588. break;
  1589. case 0x1f: 
  1590. m_sphli.StopX = ((p[1]&0x0f)<<6) + (p[2]>>2);
  1591. m_sphli.StopY = ((p[2]&0x03)<<8) + p[3];
  1592. break;
  1593. case 0x24: case 0x25: case 0x26: case 0x27: 
  1594. m_sppal[0][p[0]-0x24].Y = p[1];
  1595. m_sppal[0][p[0]-0x24].U = p[2];
  1596. m_sppal[0][p[0]-0x24].V = p[3];
  1597. break;
  1598. case 0x2c: case 0x2d: case 0x2e: case 0x2f: 
  1599. m_sppal[1][p[0]-0x2c].Y = p[1];
  1600. m_sppal[1][p[0]-0x2c].U = p[2];
  1601. m_sppal[1][p[0]-0x2c].V = p[3];
  1602. break;
  1603. case 0x37: 
  1604. m_sppal[0][3].Reserved = p[2]>>4;
  1605. m_sppal[0][2].Reserved = p[2]&0xf;
  1606. m_sppal[0][1].Reserved = p[3]>>4;
  1607. m_sppal[0][0].Reserved = p[3]&0xf;
  1608. break;
  1609. case 0x3f: 
  1610. m_sppal[1][3].Reserved = p[2]>>4;
  1611. m_sppal[1][2].Reserved = p[2]&0xf;
  1612. m_sppal[1][1].Reserved = p[3]>>4;
  1613. m_sppal[1][0].Reserved = p[3]&0xf;
  1614. break;
  1615. case 0x47: 
  1616. m_offset[0] = (p[2]<<8)|p[3];
  1617. break;
  1618. case 0x4f: 
  1619. m_offset[1] = (p[2]<<8)|p[3];
  1620. break;
  1621. default: 
  1622. break;
  1623. }
  1624. }
  1626. return(true);
  1627. }
  1629. void CSubpicInputPin::cvdspu::Render(BYTE** yuv, int w, int h, AM_DVD_YUV* sppal, bool fsppal)
  1630. {
  1631. BYTE* p = m_pData.GetData();
  1632. DWORD offset[2] = {m_offset[0], m_offset[1]};
  1634. CRect rcclip(0, 0, w, h);
  1636. /* FIXME: startx/y looks to be wrong in the sample I tested
  1637. CPoint pt(m_sphli.StartX, m_sphli.StartY);
  1638. CRect rc(pt, CPoint(m_sphli.StopX, m_sphli.StopY));
  1639. */
  1641. CSize size(m_sphli.StopX - m_sphli.StartX, m_sphli.StopY - m_sphli.StartY);
  1642. CPoint pt((rcclip.Width() - size.cx) / 2, (rcclip.Height()*3 - size.cy*1) / 4);
  1643. CRect rc(pt, size);
  1645. int nField = 0;
  1646. int fAligned = 1;
  1648. DWORD end[2] = {offset[1], (p[2]<<8)|p[3]};
  1650. while((nField == 0 && offset[0] < end[0]) || (nField == 1 && offset[1] < end[1]))
  1651. {
  1652. BYTE code;
  1654. if((code = GetNibble(p, offset, nField, fAligned)) >= 0x4)
  1655. {
  1656. DrawPixels(yuv, w, pt, code >> 2, m_sppal[0][code&3], rcclip);
  1657. pt.x += code >> 2;
  1658. continue;
  1659. }
  1661. code = GetNibble(p, offset, nField, fAligned);
  1662. DrawPixels(yuv, w, pt, rc.right - pt.x, m_sppal[0][code&3], rcclip);
  1664. if(!fAligned) GetNibble(p, offset, nField, fAligned); // align to byte
  1666. pt.x = rc.left;
  1667. pt.y++;
  1668. nField = 1 - nField;
  1669. }
  1670. }
  1672. // CSubpicInputPin::svcdspu
  1674. bool CSubpicInputPin::svcdspu::Parse()
  1675. {
  1676. BYTE* p = m_pData.GetData();
  1677. BYTE* p0 = p;
  1679. if(m_pData.GetSize() < 2) 
  1680. return(false);
  1682. WORD packetsize = (p[0]<<8)|p[1]; p += 2;
  1684.     if(packetsize > m_pData.GetSize())
  1685. return(false);
  1687. bool duration = !!(*p++&0x04);
  1689. *p++; // unknown
  1691. if(duration)
  1692. {
  1693. m_rtStop = m_rtStart + 10000i64*((p[0]<<24)|(p[1]<<16)|(p[2]<<8)|p[3])/90;
  1694. p += 4;
  1695. }
  1697. m_sphli.StartX = m_sphli.StopX = (p[0]<<8)|p[1]; p += 2;
  1698. m_sphli.StartY = m_sphli.StopY = (p[0]<<8)|p[1]; p += 2;
  1699. m_sphli.StopX += (p[0]<<8)|p[1]; p += 2;
  1700. m_sphli.StopY += (p[0]<<8)|p[1]; p += 2;
  1702. for(int i = 0; i < 4; i++)
  1703. {
  1704. m_sppal[i].Y = *p++;
  1705. m_sppal[i].U = *p++;
  1706. m_sppal[i].V = *p++;
  1707. m_sppal[i].Reserved = *p++ >> 4;
  1708. }
  1710. if(*p++&0xc0)
  1711. p += 4; // duration of the shift operation should be here, but it is untested
  1713. m_offset[1] = (p[0]<<8)|p[1]; p += 2;
  1715. m_offset[0] = p - p0;
  1716. m_offset[1] += m_offset[0];
  1718. return(true);
  1719. }
  1721. void CSubpicInputPin::svcdspu::Render(BYTE** yuv, int w, int h, AM_DVD_YUV* sppal, bool fsppal)
  1722. {
  1723. BYTE* p = m_pData.GetData();
  1724. DWORD offset[2] = {m_offset[0], m_offset[1]};
  1726. CRect rcclip(0, 0, w, h);
  1728. /* FIXME: startx/y looks to be wrong in the sample I tested (yes, this one too!)
  1729. CPoint pt(m_sphli.StartX, m_sphli.StartY);
  1730. CRect rc(pt, CPoint(m_sphli.StopX, m_sphli.StopY));
  1731. */
  1733. CSize size(m_sphli.StopX - m_sphli.StartX, m_sphli.StopY - m_sphli.StartY);
  1734. CPoint pt((rcclip.Width() - size.cx) / 2, (rcclip.Height()*3 - size.cy*1) / 4);
  1735. CRect rc(pt, size);
  1737. int nField = 0;
  1738. int n = 3;
  1740. DWORD end[2] = {offset[1], (p[2]<<8)|p[3]};
  1742. while((nField == 0 && offset[0] < end[0]) || (nField == 1 && offset[1] < end[1]))
  1743. {
  1744. BYTE code = GetHalfNibble(p, offset, nField, n);
  1745. BYTE repeat = 1 + (code == 0 ? GetHalfNibble(p, offset, nField, n) : 0);
  1747. DrawPixels(yuv, w, pt, repeat, m_sppal[code&3], rcclip);
  1748. if((pt.x += repeat) < rc.right) continue;
  1750. while(n != 3)
  1751. GetHalfNibble(p, offset, nField, n); // align to byte
  1753. pt.x = rc.left;
  1754. pt.y++;
  1755. nField = 1 - nField;
  1756. }
  1757. }
  1759. //
  1760. // CClosedCaptionOutputPin
  1761. //
  1763. CClosedCaptionOutputPin::CClosedCaptionOutputPin(CBaseFilter* pFilter, CCritSec* pLock, HRESULT* phr)
  1764. : CBaseOutputPin(NAME("CClosedCaptionOutputPin"), pFilter, pLock, phr, L"~CC")
  1765. {
  1766. }
  1768. HRESULT CClosedCaptionOutputPin::CheckMediaType(const CMediaType* mtOut)
  1769. {
  1770. return mtOut->majortype == MEDIATYPE_AUXLine21Data && mtOut->subtype == MEDIASUBTYPE_Line21_GOPPacket
  1771. ? S_OK
  1772. : VFW_E_TYPE_NOT_ACCEPTED;
  1773. }
  1775. HRESULT CClosedCaptionOutputPin::GetMediaType(int iPosition, CMediaType* pmt)
  1776. {
  1777. if(iPosition < 0) return E_INVALIDARG;
  1778. if(iPosition > 0) return VFW_S_NO_MORE_ITEMS;
  1780. pmt->InitMediaType();
  1781. pmt->majortype = MEDIATYPE_AUXLine21Data;
  1782. pmt->subtype = MEDIASUBTYPE_Line21_GOPPacket;
  1783. pmt->formattype = FORMAT_None;
  1785. return S_OK;
  1786. }
  1788. HRESULT CClosedCaptionOutputPin::DecideBufferSize(IMemAllocator* pAllocator, ALLOCATOR_PROPERTIES* pProperties)
  1789. {
  1790. pProperties->cBuffers = 1;
  1791. pProperties->cbBuffer = 2048;
  1792. pProperties->cbAlign = 1;
  1793. pProperties->cbPrefix = 0;
  1795. HRESULT hr;
  1796. ALLOCATOR_PROPERTIES Actual;
  1797.     if(FAILED(hr = pAllocator->SetProperties(pProperties, &Actual))) 
  1798. return hr;
  1800.     return pProperties->cBuffers > Actual.cBuffers || pProperties->cbBuffer > Actual.cbBuffer
  1801. ? E_FAIL
  1802. : NOERROR;
  1803. }