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

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

多媒体编程

开发平台：

Visual C++

BaseSplitterFileEx.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 "BaseSplitterFileEx.h"
  24. #include <mmreg.h>
  25. #include "......DSUtilDSUtil.h"
  26. #include <initguid.h>
  27. #include "........includemoreuuids.h"
  28. #include "........includematroskamatroska.h"
  30. //
  31. // CBaseSplitterFileEx
  32. //
  34. CBaseSplitterFileEx::CBaseSplitterFileEx(IAsyncReader* pReader, HRESULT& hr, int cachelen)
  35. : CBaseSplitterFile(pReader, hr, cachelen)
  36. , m_tslen(0)
  37. {
  38. }
  40. CBaseSplitterFileEx::~CBaseSplitterFileEx()
  41. {
  42. }
  44. //
  46. bool CBaseSplitterFileEx::NextMpegStartCode(BYTE& code, __int64 len)
  47. {
  48. BitByteAlign();
  49. DWORD dw = -1;
  50. do
  51. {
  52. if(len-- == 0 || GetPos() >= GetLength()) return(false);
  53. dw = (dw << 8) | (BYTE)BitRead(8);
  54. }
  55. while((dw&0xffffff00) != 0x00000100);
  56. code = (BYTE)(dw&0xff);
  57. return(true);
  58. }
  60. //
  62. #define MARKER if(BitRead(1) != 1) {ASSERT(0); return(false);}
  64. bool CBaseSplitterFileEx::Read(pshdr& h)
  65. {
  66. memset(&h, 0, sizeof(h));
  68. BYTE b = (BYTE)BitRead(8, true);
  70. if((b&0xf1) == 0x21)
  71. {
  72. h.type = mpeg1;
  74. EXECUTE_ASSERT(BitRead(4) == 2);
  76. h.scr = 0;
  77. h.scr |= BitRead(3) << 30; MARKER; // 32..30
  78. h.scr |= BitRead(15) << 15; MARKER; // 29..15
  79. h.scr |= BitRead(15); MARKER; MARKER; // 14..0
  80. h.bitrate = BitRead(22); MARKER;
  81. }
  82. else if((b&0xc4) == 0x44)
  83. {
  84. h.type = mpeg2;
  86. EXECUTE_ASSERT(BitRead(2) == 1);
  88. h.scr = 0;
  89. h.scr |= BitRead(3) << 30; MARKER; // 32..30
  90. h.scr |= BitRead(15) << 15; MARKER; // 29..15
  91. h.scr |= BitRead(15); MARKER; // 14..0
  92. h.scr = h.scr*300 + BitRead(9); MARKER;
  93. h.bitrate = BitRead(22); MARKER; MARKER;
  94. BitRead(5); // reserved
  95. UINT64 stuffing = BitRead(3);
  96. while(stuffing-- > 0) EXECUTE_ASSERT(BitRead(8) == 0xff);
  97. }
  98. else
  99. {
  100. return(false);
  101. }
  103. h.bitrate *= 400;
  105. return(true);
  106. }
  108. bool CBaseSplitterFileEx::Read(pssyshdr& h)
  109. {
  110. memset(&h, 0, sizeof(h));
  112. WORD len = (WORD)BitRead(16); MARKER;
  113. h.rate_bound = (DWORD)BitRead(22); MARKER;
  114. h.audio_bound = (BYTE)BitRead(6);
  115. h.fixed_rate = !!BitRead(1);
  116. h.csps = !!BitRead(1);
  117. h.sys_audio_loc_flag = !!BitRead(1);
  118. h.sys_video_loc_flag = !!BitRead(1); MARKER;
  119. h.video_bound = (BYTE)BitRead(5);
  121. EXECUTE_ASSERT((BitRead(8)&0x7f) == 0x7f); // reserved (should be 0xff, but not in reality)
  123. for(len -= 6; len > 3; len -= 3) // TODO: also store these, somewhere, if needed
  124. {
  125. UINT64 stream_id = BitRead(8);
  126. EXECUTE_ASSERT(BitRead(2) == 3);
  127. UINT64 p_std_buff_size_bound = (BitRead(1)?1024:128)*BitRead(13);
  128. }
  130. return(true);
  131. }
  133. bool CBaseSplitterFileEx::Read(peshdr& h, BYTE code)
  134. {
  135. memset(&h, 0, sizeof(h));
  137. if(!(code >= 0xbd && code < 0xf0))
  138. return(false);
  140. h.len = (WORD)BitRead(16);
  142. if(code == 0xbe || code == 0xbf)
  143. return(true);
  145. // mpeg1 stuffing (ff ff .. , max 16x)
  146. for(int i = 0; i < 16 && BitRead(8, true) == 0xff; i++)
  147. {
  148. BitRead(8); 
  149. if(h.len) h.len--;
  150. }
  152. h.type = (BYTE)BitRead(2, true) == mpeg2 ? mpeg2 : mpeg1;
  154. if(h.type == mpeg1)
  155. {
  156. BYTE b = (BYTE)BitRead(2);
  158. if(b == 1)
  159. {
  160. h.std_buff_size = (BitRead(1)?1024:128)*BitRead(13);
  161. if(h.len) h.len -= 2;
  162. b = (BYTE)BitRead(2);
  163. }
  165. if(b == 0)
  166. {
  167. h.fpts = (BYTE)BitRead(1);
  168. h.fdts = (BYTE)BitRead(1);
  169. }
  170. }
  171. else if(h.type == mpeg2)
  172. {
  173. EXECUTE_ASSERT(BitRead(2) == mpeg2);
  174. h.scrambling = (BYTE)BitRead(2);
  175. h.priority = (BYTE)BitRead(1);
  176. h.alignment = (BYTE)BitRead(1);
  177. h.copyright = (BYTE)BitRead(1);
  178. h.original = (BYTE)BitRead(1);
  179. h.fpts = (BYTE)BitRead(1);
  180. h.fdts = (BYTE)BitRead(1);
  181. h.escr = (BYTE)BitRead(1);
  182. h.esrate = (BYTE)BitRead(1);
  183. h.dsmtrickmode = (BYTE)BitRead(1);
  184. h.morecopyright = (BYTE)BitRead(1);
  185. h.crc = (BYTE)BitRead(1);
  186. h.extension = (BYTE)BitRead(1);
  187. h.hdrlen = (BYTE)BitRead(8);
  188. }
  189. else
  190. {
  191. if(h.len) while(h.len-- > 0) BitRead(8);
  192. return(false);
  193. }
  195. if(h.fpts)
  196. {
  197. if(h.type == mpeg2)
  198. {
  199. BYTE b = (BYTE)BitRead(4);
  200. if(!(h.fdts && b == 3 || !h.fdts && b == 2)) {ASSERT(0); return(false);}
  201. }
  203. h.pts = 0;
  204. h.pts |= BitRead(3) << 30; MARKER; // 32..30
  205. h.pts |= BitRead(15) << 15; MARKER; // 29..15
  206. h.pts |= BitRead(15); MARKER; // 14..0
  207. h.pts = 10000*h.pts/90;
  208. }
  210. if(h.fdts)
  211. {
  212. if((BYTE)BitRead(4) != 1) {ASSERT(0); return(false);}
  214. h.dts = 0;
  215. h.dts |= BitRead(3) << 30; MARKER; // 32..30
  216. h.dts |= BitRead(15) << 15; MARKER; // 29..15
  217. h.dts |= BitRead(15); MARKER; // 14..0
  218. h.dts = 10000*h.dts/90;
  219. }
  221. // skip to the end of header
  223. if(h.type == mpeg1)
  224. {
  225. if(!h.fpts && !h.fdts && BitRead(4) != 0xf) {/*ASSERT(0);*/ return(false);}
  227. if(h.len)
  228. {
  229. h.len--;
  230. if(h.pts) h.len -= 4;
  231. if(h.dts) h.len -= 5;
  232. }
  233. }
  235. if(h.type == mpeg2)
  236. {
  237. if(h.len) h.len -= 3+h.hdrlen;
  239. int left = h.hdrlen;
  240. if(h.fpts) left -= 5;
  241. if(h.fdts) left -= 5;
  242. while(left-- > 0) BitRead(8);
  243. /*
  244. // mpeg2 stuffing (ff ff .. , max 32x)
  245. while(BitRead(8, true) == 0xff) {BitRead(8); if(h.len) h.len--;}
  246. Seek(GetPos()); // put last peeked byte back for Read()
  248. // FIXME: this doesn't seems to be here, 
  249. // infact there can be ff's as part of the data 
  250. // right at the beginning of the packet, which 
  251. // we should not skip...
  252. */
  253. }
  255. return(true);
  256. }
  258. bool CBaseSplitterFileEx::Read(seqhdr& h, int len, CMediaType* pmt)
  259. {
  260. __int64 endpos = GetPos() + len; // - sequence header length
  262. BYTE id = 0;
  264. while(GetPos() < endpos && id != 0xb3)
  265. {
  266. if(!NextMpegStartCode(id, len))
  267. return(false);
  268. }
  270. if(id != 0xb3)
  271. return(false);
  273. __int64 shpos = GetPos() - 4;
  275. h.width = (WORD)BitRead(12);
  276. h.height = (WORD)BitRead(12);
  277. h.ar = BitRead(4);
  278.     static int ifps[16] = {0, 1126125, 1125000, 1080000, 900900, 900000, 540000, 450450, 450000, 0, 0, 0, 0, 0, 0, 0};
  279. h.ifps = ifps[BitRead(4)];
  280. h.bitrate = (DWORD)BitRead(18); MARKER;
  281. h.vbv = (DWORD)BitRead(10);
  282. h.constrained = BitRead(1);
  284. if(h.fiqm = BitRead(1))
  285. for(int i = 0; i < countof(h.iqm); i++)
  286. h.iqm[i] = (BYTE)BitRead(8);
  288. if(h.fniqm = BitRead(1))
  289. for(int i = 0; i < countof(h.niqm); i++)
  290. h.niqm[i] = (BYTE)BitRead(8);
  292. __int64 shlen = GetPos() - shpos;
  294. static float ar[] = 
  295. {
  296. 1.0000f,1.0000f,0.6735f,0.7031f,0.7615f,0.8055f,0.8437f,0.8935f,
  297. 0.9157f,0.9815f,1.0255f,1.0695f,1.0950f,1.1575f,1.2015f,1.0000f
  298. };
  300. h.arx = (int)((float)h.width / ar[h.ar] + 0.5);
  301. h.ary = h.height;
  303. mpeg_t type = mpeg1;
  305. __int64 shextpos = 0, shextlen = 0;
  307. if(NextMpegStartCode(id, 8) && id == 0xb5) // sequence header ext
  308. {
  309. shextpos = GetPos() - 4;
  311. h.startcodeid = BitRead(4);
  312. h.profile_levelescape = BitRead(1); // reserved, should be 0
  313. h.profile = BitRead(3);
  314. h.level = BitRead(4);
  315. h.progressive = BitRead(1);
  316. h.chroma = BitRead(2);
  317. h.width |= (BitRead(2)<<12);
  318. h.height |= (BitRead(2)<<12);
  319. h.bitrate |= (BitRead(12)<<18); MARKER;
  320. h.vbv |= (BitRead(8)<<10);
  321. h.lowdelay = BitRead(1);
  322. h.ifps = (DWORD)(h.ifps * (BitRead(2)+1) / (BitRead(5)+1));
  324. shextlen = GetPos() - shextpos;
  326. struct {DWORD x, y;} ar[] = {{h.width,h.height},{4,3},{16,9},{221,100},{h.width,h.height}};
  327. int i = min(max(h.ar, 1), 5)-1;
  328. h.arx = ar[i].x;
  329. h.ary = ar[i].y;
  331. type = mpeg2;
  332. }
  334. h.ifps = 10 * h.ifps / 27;
  335. h.bitrate = h.bitrate == (1<<30)-1 ? 0 : h.bitrate * 400;
  337. DWORD a = h.arx, b = h.ary;
  338.     while(a) {DWORD tmp = a; a = b % tmp; b = tmp;}
  339. if(b) h.arx /= b, h.ary /= b;
  341. if(!pmt) return(true);
  343. pmt->majortype = MEDIATYPE_Video;
  345. if(type == mpeg1)
  346. {
  347. pmt->subtype = MEDIASUBTYPE_MPEG1Payload;
  348. pmt->formattype = FORMAT_MPEGVideo;
  349. int len = FIELD_OFFSET(MPEG1VIDEOINFO, bSequenceHeader) + shlen + shextlen;
  350. MPEG1VIDEOINFO* vi = (MPEG1VIDEOINFO*)new BYTE[len];
  351. memset(vi, 0, len);
  352. vi->hdr.dwBitRate = h.bitrate;
  353. vi->hdr.AvgTimePerFrame = h.ifps;
  354. vi->hdr.bmiHeader.biSize = sizeof(vi->hdr.bmiHeader);
  355. vi->hdr.bmiHeader.biWidth = h.width;
  356. vi->hdr.bmiHeader.biHeight = h.height;
  357. vi->hdr.bmiHeader.biXPelsPerMeter = h.width * h.ary;
  358. vi->hdr.bmiHeader.biYPelsPerMeter = h.height * h.arx;
  359. vi->cbSequenceHeader = shlen;
  360. Seek(shpos);
  361. Read((BYTE*)&vi->bSequenceHeader[0], shlen);
  362. if(shextpos && shextlen) Seek(shextpos);
  363. Read((BYTE*)&vi->bSequenceHeader[0] + shlen, shextlen);
  364. pmt->SetFormat((BYTE*)vi, len);
  365. delete [] vi;
  366. }
  367. else if(type == mpeg2)
  368. {
  369. pmt->subtype = MEDIASUBTYPE_MPEG2_VIDEO;
  370. pmt->formattype = FORMAT_MPEG2_VIDEO;
  371. int len = FIELD_OFFSET(MPEG2VIDEOINFO, dwSequenceHeader) + shlen + shextlen;
  372. MPEG2VIDEOINFO* vi = (MPEG2VIDEOINFO*)new BYTE[len];
  373. memset(vi, 0, len);
  374. vi->hdr.dwBitRate = h.bitrate;
  375. vi->hdr.AvgTimePerFrame = h.ifps;
  376. vi->hdr.dwPictAspectRatioX = h.arx;
  377. vi->hdr.dwPictAspectRatioY = h.ary;
  378. vi->hdr.bmiHeader.biSize = sizeof(vi->hdr.bmiHeader);
  379. vi->hdr.bmiHeader.biWidth = h.width;
  380. vi->hdr.bmiHeader.biHeight = h.height;
  381. vi->dwProfile = h.profile;
  382. vi->dwLevel = h.level;
  383. vi->cbSequenceHeader = shlen;
  384. Seek(shpos);
  385. Read((BYTE*)&vi->dwSequenceHeader[0], shlen);
  386. if(shextpos && shextlen) Seek(shextpos);
  387. Read((BYTE*)&vi->dwSequenceHeader[0] + shlen, shextlen);
  388. pmt->SetFormat((BYTE*)vi, len);
  389. delete [] vi;
  390. }
  391. else
  392. {
  393. return(false);
  394. }
  396. return(true);
  397. }
  399. bool CBaseSplitterFileEx::Read(mpahdr& h, int len, bool fAllowV25, CMediaType* pmt)
  400. {
  401. memset(&h, 0, sizeof(h));
  403. int syncbits = fAllowV25 ? 11 : 12;
  405. for(; len >= 4 && BitRead(syncbits, true) != (1<<syncbits) - 1; len--)
  406. BitRead(8);
  408. if(len < 4)
  409. return(false);
  411. h.sync = BitRead(11);
  412. h.version = BitRead(2);
  413. h.layer = BitRead(2);
  414. h.crc = BitRead(1);
  415. h.bitrate = BitRead(4);
  416. h.freq = BitRead(2);
  417. h.padding = BitRead(1);
  418. h.privatebit = BitRead(1);
  419. h.channels = BitRead(2);
  420. h.modeext = BitRead(2);
  421. h.copyright = BitRead(1);
  422. h.original = BitRead(1);
  423. h.emphasis = BitRead(2);
  425. if(h.version == 1 || h.layer == 0 || h.freq == 3 || h.bitrate == 15 || h.emphasis == 2)
  426. return(false);
  428. if(h.version == 3 && h.layer == 2)
  429. {
  430. if((h.bitrate == 1 || h.bitrate == 2 || h.bitrate == 3 || h.bitrate == 5) && h.channels != 3
  431. && (h.bitrate >= 11 && h.bitrate <= 14) && h.channels == 3)
  432. return(false);
  433. }
  435. h.layer = 4 - h.layer;
  437. //
  439. static int brtbl[][5] = 
  440. {
  441. {0,0,0,0,0},
  442. {32,32,32,32,8},
  443. {64,48,40,48,16},
  444. {96,56,48,56,24},
  445. {128,64,56,64,32},
  446. {160,80,64,80,40},
  447. {192,96,80,96,48},
  448. {224,112,96,112,56},
  449. {256,128,112,128,64},
  450. {288,160,128,144,80},
  451. {320,192,160,160,96},
  452. {352,224,192,176,112},
  453. {384,256,224,192,128},
  454. {416,320,256,224,144},
  455. {448,384,320,256,160},
  456. {0,0,0,0,0},
  457. };
  459. static int brtblcol[][4] = {{0,3,4,4},{0,0,1,2}};
  460. int bitrate = 1000*brtbl[h.bitrate][brtblcol[h.version&1][h.layer]];
  461. if(bitrate == 0) return(false);
  463. static int freq[][4] = {{11025,0,22050,44100},{12000,0,24000,48000},{8000,0,16000,32000}};
  465. bool l3ext = h.layer == 3 && !(h.version&1);
  467. h.nSamplesPerSec = freq[h.freq][h.version];
  468. h.FrameSize = h.layer == 1
  469. ? (12 * bitrate / h.nSamplesPerSec + h.padding) * 4
  470. : (l3ext ? 72 : 144) * bitrate / h.nSamplesPerSec + h.padding;
  471. h.rtDuration = 10000000i64 * (h.layer == 1 ? 384 : l3ext ? 576 : 1152) / h.nSamplesPerSec;// / (h.channels == 3 ? 1 : 2);
  472. h.nBytesPerSec = bitrate / 8;
  474. if(!pmt) return(true);
  476. /*int*/ len = h.layer == 3 
  477. ? sizeof(WAVEFORMATEX/*MPEGLAYER3WAVEFORMAT*/) // no need to overcomplicate this...
  478. : sizeof(MPEG1WAVEFORMAT);
  479. WAVEFORMATEX* wfe = (WAVEFORMATEX*)new BYTE[len];
  480. memset(wfe, 0, len);
  481. wfe->cbSize = len - sizeof(WAVEFORMATEX);
  483. if(h.layer == 3)
  484. {
  485. wfe->wFormatTag = WAVE_FORMAT_MP3;
  487. /* MPEGLAYER3WAVEFORMAT* f = (MPEGLAYER3WAVEFORMAT*)wfe;
  488. f->wfx.wFormatTag = WAVE_FORMAT_MP3;
  489. f->wID = MPEGLAYER3_ID_UNKNOWN;
  490. f->fdwFlags = h.padding ? MPEGLAYER3_FLAG_PADDING_ON : MPEGLAYER3_FLAG_PADDING_OFF; // _OFF or _ISO ?
  491. */
  492. }
  493. else
  494. {
  495. MPEG1WAVEFORMAT* f = (MPEG1WAVEFORMAT*)wfe;
  496. f->wfx.wFormatTag = WAVE_FORMAT_MPEG;
  497. f->fwHeadMode = 1 << h.channels;
  498. f->fwHeadModeExt = 1 << h.modeext;
  499. f->wHeadEmphasis = h.emphasis+1;
  500. if(h.privatebit) f->fwHeadFlags |= ACM_MPEG_PRIVATEBIT;
  501. if(h.copyright) f->fwHeadFlags |= ACM_MPEG_COPYRIGHT;
  502. if(h.original) f->fwHeadFlags |= ACM_MPEG_ORIGINALHOME;
  503. if(h.crc == 0) f->fwHeadFlags |= ACM_MPEG_PROTECTIONBIT;
  504. if(h.version == 3) f->fwHeadFlags |= ACM_MPEG_ID_MPEG1;
  505. f->fwHeadLayer = 1 << (h.layer-1);
  506. f->dwHeadBitrate = bitrate;
  507. }
  509. wfe->nChannels = h.channels == 3 ? 1 : 2;
  510. wfe->nSamplesPerSec = h.nSamplesPerSec;
  511. wfe->nBlockAlign = h.FrameSize;
  512. wfe->nAvgBytesPerSec = h.nBytesPerSec;
  514. pmt->majortype = MEDIATYPE_Audio;
  515. pmt->subtype = FOURCCMap(wfe->wFormatTag);
  516. pmt->formattype = FORMAT_WaveFormatEx;
  517. pmt->SetFormat((BYTE*)wfe, sizeof(WAVEFORMATEX) + wfe->cbSize);
  519. delete [] wfe;
  521. return(true);
  522. }
  524. bool CBaseSplitterFileEx::Read(aachdr& h, int len, CMediaType* pmt)
  525. {
  526. memset(&h, 0, sizeof(h));
  528. for(; len >= 7 && BitRead(12, true) != 0xfff; len--)
  529. BitRead(8);
  531. if(len < 7)
  532. return(false);
  534. h.sync = BitRead(12);
  535. h.version = BitRead(1);
  536. h.layer = BitRead(2);
  537. h.fcrc = BitRead(1);
  538. h.profile = BitRead(2);
  539. h.freq = BitRead(4);
  540. h.privatebit = BitRead(1);
  541. h.channels = BitRead(3);
  542. h.original = BitRead(1);
  543. h.home = BitRead(1);
  545. h.copyright_id_bit = BitRead(1);
  546. h.copyright_id_start = BitRead(1);
  547. h.aac_frame_length = BitRead(13);
  548. h.adts_buffer_fullness = BitRead(11);
  549. h.no_raw_data_blocks_in_frame = BitRead(2);
  551. if(h.fcrc == 0) h.crc = BitRead(16);
  553. if(h.layer != 0 || h.freq >= 12 || h.aac_frame_length <= (h.fcrc == 0 ? 9 : 7))
  554. return(false);
  556. h.FrameSize = h.aac_frame_length - (h.fcrc == 0 ? 9 : 7);
  557.     static int freq[] = {96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000};
  558. h.nBytesPerSec = h.aac_frame_length * freq[h.freq] / 1024; // ok?
  559. h.rtDuration = 10000000i64 * 1024 / freq[h.freq]; // ok?
  561. if(!pmt) return(true);
  563. WAVEFORMATEX* wfe = (WAVEFORMATEX*)new BYTE[sizeof(WAVEFORMATEX)+5];
  564. memset(wfe, 0, sizeof(WAVEFORMATEX)+5);
  565. wfe->wFormatTag = WAVE_FORMAT_AAC;
  566. wfe->nChannels = h.channels <= 6 ? h.channels : 2;
  567. wfe->nSamplesPerSec = freq[h.freq];
  568. wfe->nBlockAlign = h.aac_frame_length;
  569. wfe->nAvgBytesPerSec = h.nBytesPerSec;
  570. wfe->cbSize = MakeAACInitData((BYTE*)(wfe+1), h.profile, wfe->nSamplesPerSec, wfe->nChannels);
  572. pmt->majortype = MEDIATYPE_Audio;
  573. pmt->subtype = MEDIASUBTYPE_AAC;
  574. pmt->formattype = FORMAT_WaveFormatEx;
  575. pmt->SetFormat((BYTE*)wfe, sizeof(WAVEFORMATEX)+wfe->cbSize);
  577. delete [] wfe;
  579. return(true);
  580. }
  582. bool CBaseSplitterFileEx::Read(ac3hdr& h, int len, CMediaType* pmt)
  583. {
  584. memset(&h, 0, sizeof(h));
  586. for(; len >= 7 && BitRead(16, true) != 0x0b77; len--)
  587. BitRead(8);
  589. if(len < 7)
  590. return(false);
  592. h.sync = (WORD)BitRead(16);
  593. h.crc1 = (WORD)BitRead(16);
  594. h.fscod = BitRead(2);
  595. h.frmsizecod = BitRead(6);
  596. h.bsid = BitRead(5);
  597. h.bsmod = BitRead(3);
  598. h.acmod = BitRead(3);
  599. if((h.acmod & 1) && h.acmod != 1) h.cmixlev = BitRead(2);
  600. if(h.acmod & 4) h.surmixlev = BitRead(2);
  601. if(h.acmod == 2) h.dsurmod = BitRead(2);
  602. h.lfeon = BitRead(1);
  604. if(h.bsid >= 12 || h.fscod == 3 || h.frmsizecod >= 38)
  605. return(false);
  607. if(!pmt) return(true);
  609. WAVEFORMATEX wfe;
  610. memset(&wfe, 0, sizeof(wfe));
  611. wfe.wFormatTag = WAVE_FORMAT_DOLBY_AC3;
  613. static int channels[] = {2, 1, 2, 3, 3, 4, 4, 5};
  614. wfe.nChannels = channels[h.acmod] + h.lfeon;
  616. static int freq[] = {48000, 44100, 32000, 0};
  617. wfe.nSamplesPerSec = freq[h.fscod];
  619. switch(h.bsid)
  620. {
  621. case 9: wfe.nSamplesPerSec >>= 1; break;
  622. case 10: wfe.nSamplesPerSec >>= 2; break;
  623. case 11: wfe.nSamplesPerSec >>= 3; break;
  624. default: break;
  625. }
  627. static int rate[] = {32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 448, 512, 576, 640};
  629. wfe.nAvgBytesPerSec = rate[h.frmsizecod>>1] * 1000 / 8;
  630. wfe.nBlockAlign = (WORD)(1536 * wfe.nAvgBytesPerSec / wfe.nSamplesPerSec);
  632. pmt->majortype = MEDIATYPE_Audio;
  633. pmt->subtype = MEDIASUBTYPE_DOLBY_AC3;
  634. pmt->formattype = FORMAT_WaveFormatEx;
  635. pmt->SetFormat((BYTE*)&wfe, sizeof(wfe));
  637. return(true);
  638. }
  640. bool CBaseSplitterFileEx::Read(dtshdr& h, int len, CMediaType* pmt)
  641. {
  642. memset(&h, 0, sizeof(h));
  644. for(; len >= 10 && BitRead(32, true) != 0x7ffe8001; len--)
  645. BitRead(8);
  647. if(len < 10)
  648. return(false);
  650. h.sync = (DWORD)BitRead(32);
  651. h.frametype = BitRead(1);
  652. h.deficitsamplecount = BitRead(5);
  653. h.fcrc = BitRead(1);
  654. h.nblocks = BitRead(7);
  655. h.framebytes = (WORD)BitRead(14)+1;
  656. h.amode = BitRead(6);
  657. h.sfreq = BitRead(4);
  658. h.rate = BitRead(5);
  660. if(!pmt) return(true);
  662. WAVEFORMATEX wfe;
  663. memset(&wfe, 0, sizeof(wfe));
  664. wfe.wFormatTag = WAVE_FORMAT_DVD_DTS;
  666. static int channels[] = {1, 2, 2, 2, 2, 3, 3, 4, 4, 5, 6, 6, 6, 7, 8, 8};
  667. if(h.amode < countof(channels)) wfe.nChannels = channels[h.amode];
  669. static int freq[] = {0,8000,16000,32000,0,0,11025,22050,44100,0,0,12000,24000,48000,0,0};
  670. wfe.nSamplesPerSec = freq[h.sfreq];
  672. static int rate[] = 
  673. {
  674. 32000,56000,64000,96000,112000,128000,192000,224000,
  675. 256000,320000,384000,448000,512000,576000,640000,754500,
  676. 960000,1024000,1152000,1280000,1344000,1408000,1411200,1472000,
  677. 1509750,1920000,2048000,3072000,3840000,0,0,0
  678. };
  680. wfe.nAvgBytesPerSec = rate[h.rate] * 1000 / 8;
  681. wfe.nBlockAlign = h.framebytes;
  683. pmt->majortype = MEDIATYPE_Audio;
  684. pmt->subtype = MEDIASUBTYPE_DTS;
  685. pmt->formattype = FORMAT_WaveFormatEx;
  686. pmt->SetFormat((BYTE*)&wfe, sizeof(wfe));
  688. return(true);
  689. }
  691. bool CBaseSplitterFileEx::Read(lpcmhdr& h, CMediaType* pmt)
  692. {
  693. memset(&h, 0, sizeof(h));
  695. h.emphasis = BitRead(1);
  696. h.mute = BitRead(1);
  697. h.reserved1 = BitRead(1);
  698. h.framenum = BitRead(5);
  699. h.quantwordlen = BitRead(2);
  700. h.freq = BitRead(2);
  701. h.reserved2 = BitRead(1);
  702. h.channels = BitRead(3);
  703. h.drc = (BYTE)BitRead(8);
  705. if(h.channels > 2 || h.reserved1 || h.reserved2)
  706. return(false);
  708. if(!pmt) return(true);
  710. WAVEFORMATEX wfe;
  711. memset(&wfe, 0, sizeof(wfe));
  712. wfe.wFormatTag = WAVE_FORMAT_PCM;
  713. wfe.nChannels = h.channels+1;
  714. static int freq[] = {48000, 96000, 44100, 32000};
  715. wfe.nSamplesPerSec = freq[h.freq];
  716. wfe.wBitsPerSample = 16;
  717. wfe.nBlockAlign = wfe.nChannels*wfe.wBitsPerSample>>3;
  718. wfe.nAvgBytesPerSec = wfe.nBlockAlign*wfe.nSamplesPerSec;
  720. pmt->majortype = MEDIATYPE_Audio;
  721. pmt->subtype = MEDIASUBTYPE_DVD_LPCM_AUDIO;
  722. pmt->formattype = FORMAT_WaveFormatEx;
  723. pmt->SetFormat((BYTE*)&wfe, sizeof(wfe));
  725. // TODO: what to do with dvd-audio lpcm?
  727. return(true);
  728. }
  730. bool CBaseSplitterFileEx::Read(dvdspuhdr& h, CMediaType* pmt)
  731. {
  732. memset(&h, 0, sizeof(h));
  734. if(!pmt) return(true);
  736. pmt->majortype = MEDIATYPE_Video;
  737. pmt->subtype = MEDIASUBTYPE_DVD_SUBPICTURE;
  738. pmt->formattype = FORMAT_None;
  740. return(true);
  741. }
  743. bool CBaseSplitterFileEx::Read(svcdspuhdr& h, CMediaType* pmt)
  744. {
  745. memset(&h, 0, sizeof(h));
  747. if(!pmt) return(true);
  749. pmt->majortype = MEDIATYPE_Video;
  750. pmt->subtype = MEDIASUBTYPE_SVCD_SUBPICTURE;
  751. pmt->formattype = FORMAT_None;
  753. return(true);
  754. }
  756. bool CBaseSplitterFileEx::Read(cvdspuhdr& h, CMediaType* pmt)
  757. {
  758. memset(&h, 0, sizeof(h));
  760. if(!pmt) return(true);
  762. pmt->majortype = MEDIATYPE_Video;
  763. pmt->subtype = MEDIASUBTYPE_CVD_SUBPICTURE;
  764. pmt->formattype = FORMAT_None;
  766. return(true);
  767. }
  769. bool CBaseSplitterFileEx::Read(ps2audhdr& h, CMediaType* pmt)
  770. {
  771. memset(&h, 0, sizeof(h));
  773. if(BitRead(16, true) != 'SS')
  774. return(false);
  776. __int64 pos = GetPos();
  778. while(BitRead(16, true) == 'SS')
  779. {
  780. DWORD tag = (DWORD)BitRead(32, true);
  781. DWORD size = 0;
  783. if(tag == 'SShd')
  784. {
  785. BitRead(32);
  786. Read((BYTE*)&size, sizeof(size));
  787. ASSERT(size == 0x18);
  788. Seek(GetPos());
  789. Read((BYTE*)&h, sizeof(h));
  790. }
  791. else if(tag == 'SSbd')
  792. {
  793. BitRead(32);
  794. Read((BYTE*)&size, sizeof(size));
  795. break;
  796. }
  797. }
  799. Seek(pos);
  801. if(!pmt) return(true);
  803. WAVEFORMATEXPS2 wfe;
  804. wfe.wFormatTag = 
  805. h.unk1 == 0x01 ? WAVE_FORMAT_PS2_PCM : 
  806. h.unk1 == 0x10 ? WAVE_FORMAT_PS2_ADPCM :
  807. WAVE_FORMAT_UNKNOWN;
  808. wfe.nChannels = (WORD)h.channels;
  809. wfe.nSamplesPerSec = h.freq;
  810. wfe.wBitsPerSample = 16; // always?
  811. wfe.nBlockAlign = wfe.nChannels*wfe.wBitsPerSample>>3;
  812. wfe.nAvgBytesPerSec = wfe.nBlockAlign*wfe.nSamplesPerSec;
  813. wfe.dwInterleave = h.interleave;
  815. pmt->majortype = MEDIATYPE_Audio;
  816. pmt->subtype = FOURCCMap(wfe.wFormatTag);
  817. pmt->formattype = FORMAT_WaveFormatEx;
  818. pmt->SetFormat((BYTE*)&wfe, sizeof(wfe));
  820. return(true);
  821. }
  823. bool CBaseSplitterFileEx::Read(ps2subhdr& h, CMediaType* pmt)
  824. {
  825. memset(&h, 0, sizeof(h));
  827. if(!pmt) return(true);
  829. pmt->majortype = MEDIATYPE_Subtitle;
  830. pmt->subtype = MEDIASUBTYPE_PS2_SUB;
  831. pmt->formattype = FORMAT_None;
  833. return(true);
  834. }
  836. bool CBaseSplitterFileEx::Read(trhdr& h, bool fSync)
  837. {
  838. memset(&h, 0, sizeof(h));
  840. BitByteAlign();
  842. if(m_tslen == 0)
  843. {
  844. __int64 pos = GetPos();
  846. for(int i = 0; i < 192; i++)
  847. {
  848. if(BitRead(8, true) == 0x47)
  849. {
  850. __int64 pos = GetPos();
  851. Seek(pos + 188);
  852. if(BitRead(8, true) == 0x47) {m_tslen = 188; break;}
  853. Seek(pos + 192);
  854. if(BitRead(8, true) == 0x47) {m_tslen = 192; break;}
  855. }
  857. BitRead(8);
  858. }
  860. Seek(pos);
  862. if(m_tslen == 0)
  863. {
  864. return(false);
  865. }
  866. }
  868. if(fSync)
  869. {
  870. for(int i = 0; i < m_tslen; i++)
  871. {
  872. if(BitRead(8, true) == 0x47)
  873. {
  874. if(i == 0) break;
  875. Seek(GetPos()+m_tslen);
  876. if(BitRead(8, true) == 0x47) {Seek(GetPos()-m_tslen); break;}
  877. }
  879. BitRead(8);
  881. if(i == m_tslen-1)
  882. return(false);
  883. }
  884. }
  886. if(BitRead(8, true) != 0x47)
  887. return(false);
  889. h.next = GetPos() + m_tslen;
  891. h.sync = (BYTE)BitRead(8);
  892. h.error = BitRead(1);
  893. h.payloadstart = BitRead(1);
  894. h.transportpriority = BitRead(1);
  895. h.pid = BitRead(13);
  896. h.scrambling = BitRead(2);
  897. h.adapfield = BitRead(1);
  898. h.payload = BitRead(1);
  899. h.counter = BitRead(4);
  901. h.bytes = 184;
  903. if(h.adapfield)
  904. {
  905. h.length = (BYTE)BitRead(8);
  906. h.discontinuity = BitRead(1);
  907. h.randomaccess = BitRead(1);
  908. h.priority = BitRead(1);
  909. h.PCR = BitRead(1);
  910. h.OPCR = BitRead(1);
  911. h.splicingpoint = BitRead(1);
  912. h.privatedata = BitRead(1);
  913. h.extension = BitRead(1);
  914. if(!(0 < h.length && h.length <= 183))
  915. return(false);
  916. for(int i = 1; i < h.length; i++)
  917. BitRead(8);
  919. h.bytes = 183 - h.length;
  920. }
  922. return(true);
  923. }
  925. bool CBaseSplitterFileEx::Read(pvahdr& h, bool fSync)
  926. {
  927. memset(&h, 0, sizeof(h));
  929. BitByteAlign();
  931. if(fSync)
  932. {
  933. for(int i = 0; i < 65536; i++)
  934. {
  935. if((BitRead(64, true)&0xfffffc00ffe00000i64) == 0x4156000055000000i64) 
  936. break;
  937. BitRead(8);
  938. }
  939. }
  941. if((BitRead(64, true)&0xfffffc00ffe00000i64) != 0x4156000055000000i64)
  942. return(false);
  944. h.sync = (WORD)BitRead(16);
  945. h.streamid = (BYTE)BitRead(8);
  946. h.counter = (BYTE)BitRead(8);
  947. h.res1 = (BYTE)BitRead(8);
  948. h.res2 = BitRead(3);
  949. h.fpts = BitRead(1);
  950. h.postbytes = BitRead(2);
  951. h.prebytes = BitRead(2);
  952. h.length = (WORD)BitRead(16);
  954. if(h.length > 6136)
  955. return(false);
  957. __int64 pos = GetPos();
  959. if(h.streamid == 1 && h.fpts)
  960. {
  961. h.pts = 10000*BitRead(32)/90;
  962. }
  963. else if(h.streamid == 2 && (h.fpts || (BitRead(32, true)&0xffffffe0) == 0x000001c0))
  964. {
  965. BYTE b;
  966. if(!NextMpegStartCode(b, 4)) return(false);
  967. peshdr h2;
  968. if(!Read(h2, b)) return(false);
  969. if(h.fpts = h2.fpts) h.pts = h2.pts;
  970. }
  972. BitRead(8*h.prebytes);
  974. h.length -= GetPos() - pos;
  976. return(true);
  977. }
  979. bool CBaseSplitterFileEx::Read(avchdr& h, int len, CMediaType* pmt)
  980. {
  981. __int64 endpos = GetPos() + len; // - sequence header length
  983. __int64 spspos = 0, spslen = 0;
  984. __int64 ppspos = 0, ppslen = 0;
  986. while(GetPos() < endpos+4 && BitRead(32, true) == 0x00000001)
  987. {
  988. __int64 pos = GetPos();
  990. BitRead(32);
  991. BYTE id = BitRead(8);
  993. if(spspos != 0 && spslen == 0) spslen = pos - spspos;
  994. else if(ppspos != 0 && ppslen == 0) ppslen = pos - ppspos;
  996. if((id&0x9f) == 0x07 && (id&0x60) != 0)
  997. {
  998. spspos = pos;
  1000. h.profile = (BYTE)BitRead(8);
  1001. BitRead(8);
  1002. h.level = (BYTE)BitRead(8);
  1004. UExpGolombRead(); // seq_parameter_set_id
  1005. UExpGolombRead(); // log2_max_frame_num_minus4
  1007. UINT64 pic_order_cnt_type = UExpGolombRead();
  1009. if(pic_order_cnt_type == 0)
  1010. {
  1011. UExpGolombRead(); // log2_max_pic_order_cnt_lsb_minus4
  1012. }
  1013. else if(pic_order_cnt_type == 1)
  1014. {
  1015. BitRead(1); // delta_pic_order_always_zero_flag
  1016. SExpGolombRead(); // offset_for_non_ref_pic
  1017. SExpGolombRead(); // offset_for_top_to_bottom_field
  1018. UINT64 num_ref_frames_in_pic_order_cnt_cycle = UExpGolombRead();
  1019. for(int i = 0; i < num_ref_frames_in_pic_order_cnt_cycle; i++)
  1020. SExpGolombRead(); // offset_for_ref_frame[i]
  1021. }
  1023. UExpGolombRead(); // num_ref_frames
  1024. BitRead(1); // gaps_in_frame_num_value_allowed_flag
  1026. UINT64 pic_width_in_mbs_minus1 = UExpGolombRead();
  1027. UINT64 pic_height_in_map_units_minus1 = UExpGolombRead();
  1028. BYTE frame_mbs_only_flag = (BYTE)BitRead(1);
  1030. h.width = (pic_width_in_mbs_minus1 + 1) * 16;
  1031. h.height = (2 - frame_mbs_only_flag) * (pic_height_in_map_units_minus1 + 1) * 16;
  1032. }
  1033. else if((id&0x9f) == 0x08 && (id&0x60) != 0)
  1034. {
  1035. ppspos = pos;
  1036. }
  1038. BitByteAlign();
  1040. while(GetPos() < endpos+4 && BitRead(32, true) != 0x00000001)
  1041. BitRead(8);
  1042. }
  1044. if(!spspos || !spslen || !ppspos || !ppslen) 
  1045. return(false);
  1047. if(!pmt) return(true);
  1049. {
  1050. pmt->majortype = MEDIATYPE_Video;
  1051. pmt->subtype = MEDIASUBTYPE_MPEG2_VIDEO;
  1052. pmt->formattype = FORMAT_MPEG2_VIDEO;
  1053. int len = FIELD_OFFSET(MPEG2VIDEOINFO, dwSequenceHeader) + spslen + ppslen;
  1054. MPEG2VIDEOINFO* vi = (MPEG2VIDEOINFO*)new BYTE[len];
  1055. memset(vi, 0, len);
  1056. // vi->hdr.dwBitRate = ;
  1057. // vi->hdr.AvgTimePerFrame = ;
  1058. vi->hdr.dwPictAspectRatioX = h.width;
  1059. vi->hdr.dwPictAspectRatioY = h.height;
  1060. vi->hdr.bmiHeader.biSize = sizeof(vi->hdr.bmiHeader);
  1061. vi->hdr.bmiHeader.biWidth = h.width;
  1062. vi->hdr.bmiHeader.biHeight = h.height;
  1063. vi->hdr.bmiHeader.biCompression = '1cva';
  1064. vi->dwProfile = h.profile;
  1065. vi->dwFlags = 4; // ?
  1066. vi->dwLevel = h.level;
  1067. vi->cbSequenceHeader = spslen + ppslen;
  1068. Seek(spspos);
  1069. Read((BYTE*)&vi->dwSequenceHeader[0], spslen);
  1070. Seek(ppspos);
  1071. Read((BYTE*)&vi->dwSequenceHeader[0] + spslen, ppslen);
  1072. pmt->SetFormat((BYTE*)vi, len);
  1073. delete [] vi;
  1074. }
  1076. return(true);
  1077. }