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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 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. {
  87. #ifdef DO_NIST
  88.         inputstream->read_frame(3);
  89. #endif
  91. /* Get crc1 - we don't actually use this data though */
  92. bitstream_get(bs,16);
  94. /* Get the sampling rate */
  95. syncinfo->fscod  = bitstream_get(bs,2);
  97. /* Get the frame size code */
  98. syncinfo->frmsizecod = bitstream_get(bs,6);
  100. syncinfo->bit_rate = frmsizecod_tbl[syncinfo->frmsizecod].bit_rate;
  101. syncinfo->frame_size = frmsizecod_tbl[syncinfo->frmsizecod].frm_size[syncinfo->fscod];
  102. #ifdef DO_NIST
  103.         inputstream->read_frame(syncinfo->frame_size*2-5);
  104. #endif
  106. stats_printf_syncinfo(syncinfo);
  107. }
  109. /*
  110.  * This routine fills a bsi struct from the AC3 stream
  111.  */
  113. void
  114. parse_bsi(bsi_t *bsi,bitstream_t *bs)
  115. {
  116. uint_32 i;
  118. /* Check the AC-3 version number */
  119. bsi->bsid = bitstream_get(bs,5);
  121. /* Get the audio service provided by the steram */
  122. bsi->bsmod = bitstream_get(bs,3);
  124. /* Get the audio coding mode (ie how many channels)*/
  125. bsi->acmod = bitstream_get(bs,3);
  126. /* Predecode the number of full bandwidth channels as we use this
  127.  * number a lot */
  128. bsi->nfchans = nfchans[bsi->acmod];
  130. /* If it is in use, get the centre channel mix level */
  131. if ((bsi->acmod & 0x1) && (bsi->acmod != 0x1))
  132. bsi->cmixlev = bitstream_get(bs,2);
  134. /* If it is in use, get the surround channel mix level */
  135. if (bsi->acmod & 0x4)
  136. bsi->surmixlev = bitstream_get(bs,2);
  138. /* Get the dolby surround mode if in 2/0 mode */
  139. if(bsi->acmod == 0x2)
  140. bsi->dsurmod= bitstream_get(bs,2);
  142. /* Is the low frequency effects channel on? */
  143. bsi->lfeon = bitstream_get(bs,1);
  145. /* Get the dialogue normalization level */
  146. bsi->dialnorm = bitstream_get(bs,5);
  148. /* Does compression gain exist? */
  149. bsi->compre = bitstream_get(bs,1);
  150. if (bsi->compre)
  151. {
  152. /* Get compression gain */
  153. bsi->compr = bitstream_get(bs,8);
  154. }
  156. /* Does language code exist? */
  157. bsi->langcode = bitstream_get(bs,1);
  158. if (bsi->langcode)
  159. {
  160. /* Get langauge code */
  161. bsi->langcod = bitstream_get(bs,8);
  162. }
  164. /* Does audio production info exist? */
  165. bsi->audprodie = bitstream_get(bs,1);
  166. if (bsi->audprodie)
  167. {
  168. /* Get mix level */
  169. bsi->mixlevel = bitstream_get(bs,5);
  171. /* Get room type */
  172. bsi->roomtyp = bitstream_get(bs,2);
  173. }
  175. /* If we're in dual mono mode then get some extra info */
  176. if (bsi->acmod ==0)
  177. {
  178. /* Get the dialogue normalization level two */
  179. bsi->dialnorm2 = bitstream_get(bs,5);
  181. /* Does compression gain two exist? */
  182. bsi->compr2e = bitstream_get(bs,1);
  183. if (bsi->compr2e)
  184. {
  185. /* Get compression gain two */
  186. bsi->compr2 = bitstream_get(bs,8);
  187. }
  189. /* Does language code two exist? */
  190. bsi->langcod2e = bitstream_get(bs,1);
  191. if (bsi->langcod2e)
  192. {
  193. /* Get langauge code two */
  194. bsi->langcod2 = bitstream_get(bs,8);
  195. }
  197. /* Does audio production info two exist? */
  198. bsi->audprodi2e = bitstream_get(bs,1);
  199. if (bsi->audprodi2e)
  200. {
  201. /* Get mix level two */
  202. bsi->mixlevel2 = bitstream_get(bs,5);
  204. /* Get room type two */
  205. bsi->roomtyp2 = bitstream_get(bs,2);
  206. }
  207. }
  209. /* Get the copyright bit */
  210. bsi->copyrightb = bitstream_get(bs,1);
  212. /* Get the original bit */
  213. bsi->origbs = bitstream_get(bs,1);
  215. /* Does timecode one exist? */
  216. bsi->timecod1e = bitstream_get(bs,1);
  218. if(bsi->timecod1e)
  219. bsi->timecod1 = bitstream_get(bs,14);
  221. /* Does timecode two exist? */
  222. bsi->timecod2e = bitstream_get(bs,1);
  224. if(bsi->timecod2e)
  225. bsi->timecod2 = bitstream_get(bs,14);
  227. /* Does addition info exist? */
  228. bsi->addbsie = bitstream_get(bs,1);
  230. if(bsi->addbsie)
  231. {
  232. /* Get how much info is there */
  233. bsi->addbsil = bitstream_get(bs,6);
  235. /* Get the additional info */
  236. for(i=0;i<(bsi->addbsil + 1);i++)
  237. bsi->addbsi[i] = bitstream_get(bs,8);
  238. }
  240. stats_printf_bsi(bsi);
  241. }
  243. /* More pain inducing parsing */
  244. void
  245. parse_audblk(bsi_t *bsi,audblk_t *audblk,bitstream_t *bs)
  246. {
  247. int i,j;
  249. for (i=0;i < bsi->nfchans; i++)
  250. {
  251. /* Is this channel an interleaved 256 + 256 block ? */
  252. audblk->blksw[i] = bitstream_get(bs,1);
  253. }
  255. for (i=0;i < bsi->nfchans; i++)
  256. {
  257. /* Should we dither this channel? */
  258. audblk->dithflag[i] = bitstream_get(bs,1);
  259. }
  261. /* Does dynamic range control exist? */
  262. audblk->dynrnge = bitstream_get(bs,1);
  263. if (audblk->dynrnge)
  264. {
  265. /* Get dynamic range info */
  266. audblk->dynrng = bitstream_get(bs,8);
  267. }
  269. /* If we're in dual mono mode then get the second channel DR info */
  270. if (bsi->acmod == 0)
  271. {
  272. /* Does dynamic range control two exist? */
  273. audblk->dynrng2e = bitstream_get(bs,1);
  274. if (audblk->dynrng2e)
  275. {
  276. /* Get dynamic range info */
  277. audblk->dynrng2 = bitstream_get(bs,8);
  278. }
  279. }
  281. /* Does coupling strategy exist? */
  282. audblk->cplstre = bitstream_get(bs,1);
  283. if (audblk->cplstre)
  284. {
  285. /* Is coupling turned on? */
  286. audblk->cplinu = bitstream_get(bs,1);
  287. if(audblk->cplinu)
  288. {
  289. for(i=0;i < bsi->nfchans; i++)
  290. audblk->chincpl[i] = bitstream_get(bs,1);
  291. if(bsi->acmod == 0x2)
  292. audblk->phsflginu = bitstream_get(bs,1);
  293. audblk->cplbegf = bitstream_get(bs,4);
  294. audblk->cplendf = bitstream_get(bs,4);
  295. audblk->ncplsubnd = (audblk->cplendf + 2) - audblk->cplbegf + 1;
  297. /* Calculate the start and end bins of the coupling channel */
  298. audblk->cplstrtmant = (audblk->cplbegf * 12) + 37 ; 
  299. audblk->cplendmant =  ((audblk->cplendf + 3) * 12) + 37;
  301. /* The number of combined subbands is ncplsubnd minus each combined
  302.  * band */
  303. audblk->ncplbnd = audblk->ncplsubnd; 
  305. for(i=1; i< audblk->ncplsubnd; i++)
  306. {
  307. audblk->cplbndstrc[i] = bitstream_get(bs,1);
  308. audblk->ncplbnd -= audblk->cplbndstrc[i];
  309. }
  310. }
  311. }
  313. if(audblk->cplinu)
  314. {
  315. /* Loop through all the channels and get their coupling co-ords */
  316. for(i=0;i < bsi->nfchans;i++)
  317. {
  318. if(!audblk->chincpl[i])
  319. continue;
  321. /* Is there new coupling co-ordinate info? */
  322. audblk->cplcoe[i] = bitstream_get(bs,1);
  324. if(audblk->cplcoe[i])
  325. {
  326. audblk->mstrcplco[i] = bitstream_get(bs,2); 
  327. for(j=0;j < audblk->ncplbnd; j++)
  328. {
  329. audblk->cplcoexp[i][j] = bitstream_get(bs,4); 
  330. audblk->cplcomant[i][j] = bitstream_get(bs,4); 
  331. }
  332. }
  333. }
  335. /* If we're in dual mono mode, there's going to be some phase info */
  336. if( (bsi->acmod == 0x2) && audblk->phsflginu && 
  337. (audblk->cplcoe[0] || audblk->cplcoe[1]))
  338. {
  339. for(j=0;j < audblk->ncplbnd; j++)
  340. audblk->phsflg[j] = bitstream_get(bs,1); 
  342. }
  343. }
  345. /* If we're in dual mono mode, there may be a rematrix strategy */
  346. if(bsi->acmod == 0x2)
  347. {
  348. audblk->rematstr = bitstream_get(bs,1);
  349. if(audblk->rematstr)
  350. {
  351. if (audblk->cplinu == 0) 
  352. { 
  353. for(i = 0; i < 4; i++) 
  354. audblk->rematflg[i] = bitstream_get(bs,1);
  355. }
  356. if((audblk->cplbegf > 2) && audblk->cplinu) 
  357. {
  358. for(i = 0; i < 4; i++) 
  359. audblk->rematflg[i] = bitstream_get(bs,1);
  360. }
  361. if((audblk->cplbegf <= 2) && audblk->cplinu) 
  362. { 
  363. for(i = 0; i < 3; i++) 
  364. audblk->rematflg[i] = bitstream_get(bs,1);
  365. } 
  366. if((audblk->cplbegf == 0) && audblk->cplinu) 
  367. for(i = 0; i < 2; i++) 
  368. audblk->rematflg[i] = bitstream_get(bs,1);
  370. }
  371. }
  373. if (audblk->cplinu)
  374. {
  375. /* Get the coupling channel exponent strategy */
  376. audblk->cplexpstr = bitstream_get(bs,2);
  377. audblk->ncplgrps = (audblk->cplendmant - audblk->cplstrtmant) / 
  378. (3 << (audblk->cplexpstr-1));
  379. }
  381. for(i = 0; i < bsi->nfchans; i++)
  382. audblk->chexpstr[i] = bitstream_get(bs,2);
  384. /* Get the exponent strategy for lfe channel */
  385. if(bsi->lfeon) 
  386. audblk->lfeexpstr = bitstream_get(bs,1);
  388. /* Determine the bandwidths of all the fbw channels */
  389. for(i = 0; i < bsi->nfchans; i++) 
  390. { 
  391. uint_16 grp_size;
  393. if(audblk->chexpstr[i] != EXP_REUSE) 
  394. { 
  395. if (audblk->cplinu && audblk->chincpl[i]) 
  396. {
  397. audblk->endmant[i] = audblk->cplstrtmant;
  398. }
  399. else
  400. {
  401. audblk->chbwcod[i] = bitstream_get(bs,6); 
  402. audblk->endmant[i] = ((audblk->chbwcod[i] + 12) * 3) + 37;
  403. }
  405. /* Calculate the number of exponent groups to fetch */
  406. grp_size =  3 * (1 << (audblk->chexpstr[i] - 1));
  407. audblk->nchgrps[i] = (audblk->endmant[i] - 1 + (grp_size - 3)) / grp_size;
  408. }
  409. }
  411. /* Get the coupling exponents if they exist */
  412. if(audblk->cplinu && (audblk->cplexpstr != EXP_REUSE))
  413. {
  414. audblk->cplabsexp = bitstream_get(bs,4);
  415. for(i=0;i< audblk->ncplgrps;i++)
  416. audblk->cplexps[i] = bitstream_get(bs,7);
  417. }
  419. /* Get the fwb channel exponents */
  420. for(i=0;i < bsi->nfchans; i++)
  421. {
  422. if(audblk->chexpstr[i] != EXP_REUSE)
  423. {
  424. audblk->exps[i][0] = bitstream_get(bs,4);
  425. for(j=1;j<=audblk->nchgrps[i];j++)
  426. audblk->exps[i][j] = bitstream_get(bs,7);
  427. audblk->gainrng[i] = bitstream_get(bs,2);
  428. }
  429. }
  431. /* Get the lfe channel exponents */
  432. if(bsi->lfeon && (audblk->lfeexpstr != EXP_REUSE))
  433. {
  434. audblk->lfeexps[0] = bitstream_get(bs,4);
  435. audblk->lfeexps[1] = bitstream_get(bs,7);
  436. audblk->lfeexps[2] = bitstream_get(bs,7);
  437. }
  439. /* Get the parametric bit allocation parameters */
  440. audblk->baie = bitstream_get(bs,1);
  442. if(audblk->baie)
  443. {
  444. audblk->sdcycod = bitstream_get(bs,2);
  445. audblk->fdcycod = bitstream_get(bs,2);
  446. audblk->sgaincod = bitstream_get(bs,2);
  447. audblk->dbpbcod = bitstream_get(bs,2);
  448. audblk->floorcod = bitstream_get(bs,3);
  449. }
  451. /* Get the SNR off set info if it exists */
  452. audblk->snroffste = bitstream_get(bs,1);
  454. if(audblk->snroffste)
  455. {
  456. audblk->csnroffst = bitstream_get(bs,6);
  458. if(audblk->cplinu)
  459. {
  460. audblk->cplfsnroffst = bitstream_get(bs,4);
  461. audblk->cplfgaincod = bitstream_get(bs,3);
  462. }
  464. for(i = 0;i < bsi->nfchans; i++)
  465. {
  466. audblk->fsnroffst[i] = bitstream_get(bs,4);
  467. audblk->fgaincod[i] = bitstream_get(bs,3);
  468. }
  469. if(bsi->lfeon)
  470. {
  472. audblk->lfefsnroffst = bitstream_get(bs,4);
  473. audblk->lfefgaincod = bitstream_get(bs,3);
  474. }
  475. }
  477. /* Get coupling leakage info if it exists */
  478. if(audblk->cplinu)
  479. {
  480. audblk->cplleake = bitstream_get(bs,1);
  482. if(audblk->cplleake)
  483. {
  484. audblk->cplfleak = bitstream_get(bs,3);
  485. audblk->cplsleak = bitstream_get(bs,3);
  486. }
  487. }
  489. /* Get the delta bit alloaction info */
  490. audblk->deltbaie = bitstream_get(bs,1);
  492. if(audblk->deltbaie)
  493. {
  494. if(audblk->cplinu)
  495. audblk->cpldeltbae = bitstream_get(bs,2);
  497. for(i = 0;i < bsi->nfchans; i++)
  498. audblk->deltbae[i] = bitstream_get(bs,2);
  500. if (audblk->cplinu && (audblk->cpldeltbae == DELTA_BIT_NEW))
  501. {
  502. audblk->cpldeltnseg = bitstream_get(bs,3);
  503. for(i = 0;i < audblk->cpldeltnseg + 1; i++)
  504. {
  505. audblk->cpldeltoffst[i] = bitstream_get(bs,5);
  506. audblk->cpldeltlen[i] = bitstream_get(bs,4);
  507. audblk->cpldeltba[i] = bitstream_get(bs,3);
  508. }
  509. }
  511. for(i = 0;i < bsi->nfchans; i++)
  512. {
  513. if (audblk->deltbae[i] == DELTA_BIT_NEW)
  514. {
  515. audblk->deltnseg[i] = bitstream_get(bs,3);
  516. for(j = 0; j < audblk->deltnseg[i] + 1; j++)
  517. {
  518. audblk->deltoffst[i][j] = bitstream_get(bs,5);
  519. audblk->deltlen[i][j] = bitstream_get(bs,4);
  520. audblk->deltba[i][j] = bitstream_get(bs,3);
  521. }
  522. }
  523. }
  524. }
  526. /* Check to see if there's any dummy info to get */
  527. if((audblk->skiple =  bitstream_get(bs,1)))
  528. {
  529. uint_16 skip_data;
  531. audblk->skipl = bitstream_get(bs,9);
  532. //XXX remove
  533. //fprintf(stderr,"(parse) skipping %d bytesn",audblk->skipl);
  535. for(i = 0; i < audblk->skipl ; i++)
  536. {
  537. skip_data = bitstream_get(bs,8);
  538. //XXX remove
  539. //fprintf(stderr,"skipped data %2xn",skip_data);
  540. //if(skip_data != 0)
  541. //{
  542. //dprintf("(parse) Invalid skipped data %2xn",skip_data);
  543. //exit(1);
  544. //}
  545. }
  546. }
  548. stats_printf_audblk(audblk);
  549. }
  551. void
  552. parse_auxdata(syncinfo_t *syncinfo,bitstream_t *bs)
  553. {
  554. int i;
  555. int skip_length;
  556. uint_16 crc;
  557. uint_16 auxdatae;
  559. skip_length = (syncinfo->frame_size * 16)  - bs->total_bits_read - 17 - 1;
  561. //XXX remove
  562. //dprintf("(auxdata) skipping %d auxbitsn",skip_length);
  564. for(i=0; i <  skip_length; i++)
  565. //printf("Skipped bit %in",(uint_16)bitstream_get(bs,1));
  566. bitstream_get(bs,1);
  568. //get the auxdata exists bit
  569. auxdatae = bitstream_get(bs,1);
  571. //XXX remove
  572. //dprintf("auxdatae = %in",auxdatae);
  574. //Skip the CRC reserved bit
  575. bitstream_get(bs,1);
  577. //Get the crc
  578. crc = bitstream_get(bs,16);
  579. }