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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
parse.c
资源名称：dvd-munitions.tar.gz　[点击查看]
上传用户：aoeyumen
上传日期：2007-01-06
资源大小：3329k
文件大小：14k
源码类别：

DVD

开发平台：

Unix_Linux

parse.c：源码内容
  1. /* 
  2.  *    parse.c
  3.  *
  4.  * Copyright (C) Aaron Holtzman - May 1999
  5.  *
  6.  *  This file is part of ac3dec, a free Dolby AC-3 stream decoder.
  7.  *
  8.  *  ac3dec is free software; you can redistribute it and/or modify
  9.  *  it under the terms of the GNU General Public License as published by
  10.  *  the Free Software Foundation; either version 2, or (at your option)
  11.  *  any later version.
  12.  *   
  13.  *  ac3dec is distributed in the hope that it will be useful,
  14.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.  *  GNU General Public License for more details.
  17.  *   
  18.  *  You should have received a copy of the GNU General Public License
  19.  *  along with GNU Make; see the file COPYING.  If not, write to
  20.  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 
  21.  *
  22.  *
  23.  */
  25. #include <stdlib.h>
  26. #include <stdio.h>
  27. #include "ac3.h"
  28. #include "decode.h"
  29. #include "bitstream.h"
  30. #include "stats.h"
  31. #include "debug.h"
  32. #include "parse.h"
  34. /* Misc LUT */
  35. static uint_16 nfchans[] = {2,1,2,3,3,4,4,5};
  37. struct frmsize_s
  38. {
  39. uint_16 bit_rate;
  40. uint_16 frm_size[3];
  41. };
  43. struct frmsize_s frmsizecod_tbl[] = {
  44.       { 32  ,{64   ,69   ,96   } },
  45.       { 32  ,{64   ,70   ,96   } },
  46.       { 40  ,{80   ,87   ,120  } },
  47.       { 40  ,{80   ,88   ,120  } },
  48.       { 48  ,{96   ,104  ,144  } },
  49.       { 48  ,{96   ,105  ,144  } },
  50.       { 56  ,{112  ,121  ,168  } },
  51.       { 56  ,{112  ,122  ,168  } },
  52.       { 64  ,{128  ,139  ,192  } },
  53.       { 64  ,{128  ,140  ,192  } },
  54.       { 80  ,{160  ,174  ,240  } },
  55.       { 80  ,{160  ,175  ,240  } },
  56.       { 96  ,{192  ,208  ,288  } },
  57.       { 96  ,{192  ,209  ,288  } },
  58.       { 112 ,{224  ,243  ,336  } },
  59.       { 112 ,{224  ,244  ,336  } },
  60.       { 128 ,{256  ,278  ,384  } },
  61.       { 128 ,{256  ,279  ,384  } },
  62.       { 160 ,{320  ,348  ,480  } },
  63.       { 160 ,{320  ,349  ,480  } },
  64.       { 192 ,{384  ,417  ,576  } },
  65.       { 192 ,{384  ,418  ,576  } },
  66.       { 224 ,{448  ,487  ,672  } },
  67.       { 224 ,{448  ,488  ,672  } },
  68.       { 256 ,{512  ,557  ,768  } },
  69.       { 256 ,{512  ,558  ,768  } },
  70.       { 320 ,{640  ,696  ,960  } },
  71.       { 320 ,{640  ,697  ,960  } },
  72.       { 384 ,{768  ,835  ,1152 } },
  73.       { 384 ,{768  ,836  ,1152 } },
  74.       { 448 ,{896  ,975  ,1344 } },
  75.       { 448 ,{896  ,976  ,1344 } },
  76.       { 512 ,{1024 ,1114 ,1536 } },
  77.       { 512 ,{1024 ,1115 ,1536 } },
  78.       { 576 ,{1152 ,1253 ,1728 } },
  79.       { 576 ,{1152 ,1254 ,1728 } },
  80.       { 640 ,{1280 ,1393 ,1920 } },
  81.       { 640 ,{1280 ,1394 ,1920 } }};
  83. /* Parse a syncinfo structure, minus the sync word */
  84. void
  85. parse_syncinfo(syncinfo_t *syncinfo,bitstream_t *bs)
  86. {
  88. /* Get crc1 - we don't actually use this data though */
  89. bitstream_get(bs,16);
  91. /* Get the sampling rate */
  92. syncinfo->fscod  = bitstream_get(bs,2);
  94. /* Get the frame size code */
  95. syncinfo->frmsizecod = bitstream_get(bs,6);
  97. syncinfo->bit_rate = frmsizecod_tbl[syncinfo->frmsizecod].bit_rate;
  98. syncinfo->frame_size = frmsizecod_tbl[syncinfo->frmsizecod].frm_size[syncinfo->fscod];
  100. stats_printf_syncinfo(syncinfo);
  101. }
  103. /*
  104.  * This routine fills a bsi struct from the AC3 stream
  105.  */
  107. void
  108. parse_bsi(bsi_t *bsi,bitstream_t *bs)
  109. {
  110. uint_32 i;
  112. /* Check the AC-3 version number */
  113. bsi->bsid = bitstream_get(bs,5);
  115. /* Get the audio service provided by the steram */
  116. bsi->bsmod = bitstream_get(bs,3);
  118. /* Get the audio coding mode (ie how many channels)*/
  119. bsi->acmod = bitstream_get(bs,3);
  120. /* Predecode the number of full bandwidth channels as we use this
  121.  * number a lot */
  122. bsi->nfchans = nfchans[bsi->acmod];
  124. /* If it is in use, get the centre channel mix level */
  125. if ((bsi->acmod & 0x1) && (bsi->acmod != 0x1))
  126. bsi->cmixlev = bitstream_get(bs,2);
  128. /* If it is in use, get the surround channel mix level */
  129. if (bsi->acmod & 0x4)
  130. bsi->surmixlev = bitstream_get(bs,2);
  132. /* Get the dolby surround mode if in 2/0 mode */
  133. if(bsi->acmod == 0x2)
  134. bsi->dsurmod= bitstream_get(bs,2);
  136. /* Is the low frequency effects channel on? */
  137. bsi->lfeon = bitstream_get(bs,1);
  139. /* Get the dialogue normalization level */
  140. bsi->dialnorm = bitstream_get(bs,5);
  142. /* Does compression gain exist? */
  143. bsi->compre = bitstream_get(bs,1);
  144. if (bsi->compre)
  145. {
  146. /* Get compression gain */
  147. bsi->compr = bitstream_get(bs,8);
  148. }
  150. /* Does language code exist? */
  151. bsi->langcode = bitstream_get(bs,1);
  152. if (bsi->langcode)
  153. {
  154. /* Get langauge code */
  155. bsi->langcod = bitstream_get(bs,8);
  156. }
  158. /* Does audio production info exist? */
  159. bsi->audprodie = bitstream_get(bs,1);
  160. if (bsi->audprodie)
  161. {
  162. /* Get mix level */
  163. bsi->mixlevel = bitstream_get(bs,5);
  165. /* Get room type */
  166. bsi->roomtyp = bitstream_get(bs,2);
  167. }
  169. /* If we're in dual mono mode then get some extra info */
  170. if (bsi->acmod ==0)
  171. {
  172. /* Get the dialogue normalization level two */
  173. bsi->dialnorm2 = bitstream_get(bs,5);
  175. /* Does compression gain two exist? */
  176. bsi->compr2e = bitstream_get(bs,1);
  177. if (bsi->compr2e)
  178. {
  179. /* Get compression gain two */
  180. bsi->compr2 = bitstream_get(bs,8);
  181. }
  183. /* Does language code two exist? */
  184. bsi->langcod2e = bitstream_get(bs,1);
  185. if (bsi->langcod2e)
  186. {
  187. /* Get langauge code two */
  188. bsi->langcod2 = bitstream_get(bs,8);
  189. }
  191. /* Does audio production info two exist? */
  192. bsi->audprodi2e = bitstream_get(bs,1);
  193. if (bsi->audprodi2e)
  194. {
  195. /* Get mix level two */
  196. bsi->mixlevel2 = bitstream_get(bs,5);
  198. /* Get room type two */
  199. bsi->roomtyp2 = bitstream_get(bs,2);
  200. }
  201. }
  203. /* Get the copyright bit */
  204. bsi->copyrightb = bitstream_get(bs,1);
  206. /* Get the original bit */
  207. bsi->origbs = bitstream_get(bs,1);
  209. /* Does timecode one exist? */
  210. bsi->timecod1e = bitstream_get(bs,1);
  212. if(bsi->timecod1e)
  213. bsi->timecod1 = bitstream_get(bs,14);
  215. /* Does timecode two exist? */
  216. bsi->timecod2e = bitstream_get(bs,1);
  218. if(bsi->timecod2e)
  219. bsi->timecod2 = bitstream_get(bs,14);
  221. /* Does addition info exist? */
  222. bsi->addbsie = bitstream_get(bs,1);
  224. if(bsi->addbsie)
  225. {
  226. /* Get how much info is there */
  227. bsi->addbsil = bitstream_get(bs,6);
  229. /* Get the additional info */
  230. for(i=0;i<(bsi->addbsil + 1);i++)
  231. bsi->addbsi[i] = bitstream_get(bs,8);
  232. }
  234. stats_printf_bsi(bsi);
  235. }
  237. /* More pain inducing parsing */
  238. void
  239. parse_audblk(bsi_t *bsi,audblk_t *audblk,bitstream_t *bs)
  240. {
  241. int i,j;
  243. for (i=0;i < bsi->nfchans; i++)
  244. {
  245. /* Is this channel an interleaved 256 + 256 block ? */
  246. audblk->blksw[i] = bitstream_get(bs,1);
  247. }
  249. for (i=0;i < bsi->nfchans; i++)
  250. {
  251. /* Should we dither this channel? */
  252. audblk->dithflag[i] = bitstream_get(bs,1);
  253. }
  255. /* Does dynamic range control exist? */
  256. audblk->dynrnge = bitstream_get(bs,1);
  257. if (audblk->dynrnge)
  258. {
  259. /* Get dynamic range info */
  260. audblk->dynrng = bitstream_get(bs,8);
  261. }
  263. /* If we're in dual mono mode then get the second channel DR info */
  264. if (bsi->acmod == 0)
  265. {
  266. /* Does dynamic range control two exist? */
  267. audblk->dynrng2e = bitstream_get(bs,1);
  268. if (audblk->dynrng2e)
  269. {
  270. /* Get dynamic range info */
  271. audblk->dynrng2 = bitstream_get(bs,8);
  272. }
  273. }
  275. /* Does coupling strategy exist? */
  276. audblk->cplstre = bitstream_get(bs,1);
  277. if (audblk->cplstre)
  278. {
  279. /* Is coupling turned on? */
  280. audblk->cplinu = bitstream_get(bs,1);
  281. if(audblk->cplinu)
  282. {
  283. for(i=0;i < bsi->nfchans; i++)
  284. audblk->chincpl[i] = bitstream_get(bs,1);
  285. if(bsi->acmod == 0x2)
  286. audblk->phsflginu = bitstream_get(bs,1);
  287. audblk->cplbegf = bitstream_get(bs,4);
  288. audblk->cplendf = bitstream_get(bs,4);
  289. audblk->ncplsubnd = (audblk->cplendf + 2) - audblk->cplbegf + 1;
  291. /* Calculate the start and end bins of the coupling channel */
  292. audblk->cplstrtmant = (audblk->cplbegf * 12) + 37 ; 
  293. audblk->cplendmant =  ((audblk->cplendf + 3) * 12) + 37;
  295. /* The number of combined subbands is ncplsubnd minus each combined
  296.  * band */
  297. audblk->ncplbnd = audblk->ncplsubnd; 
  299. for(i=1; i< audblk->ncplsubnd; i++)
  300. {
  301. audblk->cplbndstrc[i] = bitstream_get(bs,1);
  302. audblk->ncplbnd -= audblk->cplbndstrc[i];
  303. }
  304. }
  305. }
  307. if(audblk->cplinu)
  308. {
  309. /* Loop through all the channels and get their coupling co-ords */
  310. for(i=0;i < bsi->nfchans;i++)
  311. {
  312. if(!audblk->chincpl[i])
  313. continue;
  315. /* Is there new coupling co-ordinate info? */
  316. audblk->cplcoe[i] = bitstream_get(bs,1);
  318. if(audblk->cplcoe[i])
  319. {
  320. audblk->mstrcplco[i] = bitstream_get(bs,2); 
  321. for(j=0;j < audblk->ncplbnd; j++)
  322. {
  323. audblk->cplcoexp[i][j] = bitstream_get(bs,4); 
  324. audblk->cplcomant[i][j] = bitstream_get(bs,4); 
  325. }
  326. }
  327. }
  329. /* If we're in dual mono mode, there's going to be some phase info */
  330. if( (bsi->acmod == 0x2) && audblk->phsflginu && 
  331. (audblk->cplcoe[0] || audblk->cplcoe[1]))
  332. {
  333. for(j=0;j < audblk->ncplbnd; j++)
  334. audblk->phsflg[j] = bitstream_get(bs,1); 
  336. }
  337. }
  339. /* If we're in dual mono mode, there may be a rematrix strategy */
  340. if(bsi->acmod == 0x2)
  341. {
  342. audblk->rematstr = bitstream_get(bs,1);
  343. if(audblk->rematstr)
  344. {
  345. if (audblk->cplinu == 0) 
  346. { 
  347. for(i = 0; i < 4; i++) 
  348. audblk->rematflg[i] = bitstream_get(bs,1);
  349. }
  350. if((audblk->cplbegf > 2) && audblk->cplinu) 
  351. {
  352. for(i = 0; i < 4; i++) 
  353. audblk->rematflg[i] = bitstream_get(bs,1);
  354. }
  355. if((audblk->cplbegf <= 2) && audblk->cplinu) 
  356. { 
  357. for(i = 0; i < 3; i++) 
  358. audblk->rematflg[i] = bitstream_get(bs,1);
  359. } 
  360. if((audblk->cplbegf == 0) && audblk->cplinu) 
  361. for(i = 0; i < 2; i++) 
  362. audblk->rematflg[i] = bitstream_get(bs,1);
  364. }
  365. }
  367. if (audblk->cplinu)
  368. {
  369. /* Get the coupling channel exponent strategy */
  370. audblk->cplexpstr = bitstream_get(bs,2);
  371. audblk->ncplgrps = (audblk->cplendmant - audblk->cplstrtmant) / 
  372. (3 << (audblk->cplexpstr-1));
  373. }
  375. for(i = 0; i < bsi->nfchans; i++)
  376. audblk->chexpstr[i] = bitstream_get(bs,2);
  378. /* Get the exponent strategy for lfe channel */
  379. if(bsi->lfeon) 
  380. audblk->lfeexpstr = bitstream_get(bs,1);
  382. /* Determine the bandwidths of all the fbw channels */
  383. for(i = 0; i < bsi->nfchans; i++) 
  384. { 
  385. uint_16 grp_size;
  387. if(audblk->chexpstr[i] != EXP_REUSE) 
  388. { 
  389. if (audblk->cplinu && audblk->chincpl[i]) 
  390. {
  391. audblk->endmant[i] = audblk->cplstrtmant;
  392. }
  393. else
  394. {
  395. audblk->chbwcod[i] = bitstream_get(bs,6); 
  396. audblk->endmant[i] = ((audblk->chbwcod[i] + 12) * 3) + 37;
  397. }
  399. /* Calculate the number of exponent groups to fetch */
  400. grp_size =  3 * (1 << (audblk->chexpstr[i] - 1));
  401. audblk->nchgrps[i] = (audblk->endmant[i] - 1 + (grp_size - 3)) / grp_size;
  402. }
  403. }
  405. /* Get the coupling exponents if they exist */
  406. if(audblk->cplinu && (audblk->cplexpstr != EXP_REUSE))
  407. {
  408. audblk->cplabsexp = bitstream_get(bs,4);
  409. for(i=0;i< audblk->ncplgrps;i++)
  410. audblk->cplexps[i] = bitstream_get(bs,7);
  411. }
  413. /* Get the fwb channel exponents */
  414. for(i=0;i < bsi->nfchans; i++)
  415. {
  416. if(audblk->chexpstr[i] != EXP_REUSE)
  417. {
  418. audblk->exps[i][0] = bitstream_get(bs,4);
  419. for(j=1;j<=audblk->nchgrps[i];j++)
  420. audblk->exps[i][j] = bitstream_get(bs,7);
  421. audblk->gainrng[i] = bitstream_get(bs,2);
  422. }
  423. }
  425. /* Get the lfe channel exponents */
  426. if(bsi->lfeon && (audblk->lfeexpstr != EXP_REUSE))
  427. {
  428. audblk->lfeexps[0] = bitstream_get(bs,4);
  429. audblk->lfeexps[1] = bitstream_get(bs,7);
  430. audblk->lfeexps[2] = bitstream_get(bs,7);
  431. }
  433. /* Get the parametric bit allocation parameters */
  434. audblk->baie = bitstream_get(bs,1);
  436. if(audblk->baie)
  437. {
  438. audblk->sdcycod = bitstream_get(bs,2);
  439. audblk->fdcycod = bitstream_get(bs,2);
  440. audblk->sgaincod = bitstream_get(bs,2);
  441. audblk->dbpbcod = bitstream_get(bs,2);
  442. audblk->floorcod = bitstream_get(bs,3);
  443. }
  445. /* Get the SNR off set info if it exists */
  446. audblk->snroffste = bitstream_get(bs,1);
  448. if(audblk->snroffste)
  449. {
  450. audblk->csnroffst = bitstream_get(bs,6);
  452. if(audblk->cplinu)
  453. {
  454. audblk->cplfsnroffst = bitstream_get(bs,4);
  455. audblk->cplfgaincod = bitstream_get(bs,3);
  456. }
  458. for(i = 0;i < bsi->nfchans; i++)
  459. {
  460. audblk->fsnroffst[i] = bitstream_get(bs,4);
  461. audblk->fgaincod[i] = bitstream_get(bs,3);
  462. }
  463. if(bsi->lfeon)
  464. {
  466. audblk->lfefsnroffst = bitstream_get(bs,4);
  467. audblk->lfefgaincod = bitstream_get(bs,3);
  468. }
  469. }
  471. /* Get coupling leakage info if it exists */
  472. if(audblk->cplinu)
  473. {
  474. audblk->cplleake = bitstream_get(bs,1);
  476. if(audblk->cplleake)
  477. {
  478. audblk->cplfleak = bitstream_get(bs,3);
  479. audblk->cplsleak = bitstream_get(bs,3);
  480. }
  481. }
  483. /* Get the delta bit alloaction info */
  484. audblk->deltbaie = bitstream_get(bs,1);
  486. if(audblk->deltbaie)
  487. {
  488. if(audblk->cplinu)
  489. audblk->cpldeltbae = bitstream_get(bs,2);
  491. for(i = 0;i < bsi->nfchans; i++)
  492. audblk->deltbae[i] = bitstream_get(bs,2);
  494. if (audblk->cplinu && (audblk->cpldeltbae == DELTA_BIT_NEW))
  495. {
  496. audblk->cpldeltnseg = bitstream_get(bs,3);
  497. for(i = 0;i < audblk->cpldeltnseg + 1; i++)
  498. {
  499. audblk->cpldeltoffst[i] = bitstream_get(bs,5);
  500. audblk->cpldeltlen[i] = bitstream_get(bs,4);
  501. audblk->cpldeltba[i] = bitstream_get(bs,3);
  502. }
  503. }
  505. for(i = 0;i < bsi->nfchans; i++)
  506. {
  507. if (audblk->deltbae[i] == DELTA_BIT_NEW)
  508. {
  509. audblk->deltnseg[i] = bitstream_get(bs,3);
  510. for(j = 0; j < audblk->deltnseg[i] + 1; j++)
  511. {
  512. audblk->deltoffst[i][j] = bitstream_get(bs,5);
  513. audblk->deltlen[i][j] = bitstream_get(bs,4);
  514. audblk->deltba[i][j] = bitstream_get(bs,3);
  515. }
  516. }
  517. }
  518. }
  520. /* Check to see if there's any dummy info to get */
  521. if((audblk->skiple =  bitstream_get(bs,1)))
  522. {
  523. uint_16 skip_data;
  525. audblk->skipl = bitstream_get(bs,9);
  526. //XXX remove
  527. //fprintf(stderr,"(parse) skipping %d bytesn",audblk->skipl);
  529. for(i = 0; i < audblk->skipl ; i++)
  530. {
  531. skip_data = bitstream_get(bs,8);
  532. //XXX remove
  533. //fprintf(stderr,"skipped data %2xn",skip_data);
  534. //if(skip_data != 0)
  535. //{
  536. //dprintf("(parse) Invalid skipped data %2xn",skip_data);
  537. //exit(1);
  538. //}
  539. }
  540. }
  542. stats_printf_audblk(audblk);
  543. }
  545. void
  546. parse_auxdata(syncinfo_t *syncinfo,bitstream_t *bs)
  547. {
  548. int i;
  549. int skip_length;
  550. uint_16 crc;
  551. uint_16 auxdatae;
  553. skip_length = (syncinfo->frame_size * 16)  - bs->total_bits_read - 17 - 1;
  555. //XXX remove
  556. //dprintf("(auxdata) skipping %d auxbitsn",skip_length);
  558. for(i=0; i <  skip_length; i++)
  559. //printf("Skipped bit %in",(uint_16)bitstream_get(bs,1));
  560. bitstream_get(bs,1);
  562. //get the auxdata exists bit
  563. auxdatae = bitstream_get(bs,1);
  565. //XXX remove
  566. //dprintf("auxdatae = %in",auxdatae);
  568. //Skip the CRC reserved bit
  569. bitstream_get(bs,1);
  571. //Get the crc
  572. crc = bitstream_get(bs,16);
  573. }