git.sesse.net Git - vlc/blob - src/ac3_decoder/ac3_parse.c

   1 /*****************************************************************************
   2  * ac3_parse.c: ac3 parsing procedures
   3  *****************************************************************************
   4  * Copyright (C) 1999, 2000, 2001 VideoLAN
   5  *
   6  * Authors: Michel Kaempf <maxx@via.ecp.fr>
   7  *          Aaron Holtzman <aholtzma@engr.uvic.ca>
   8  *          Renaud Dartus <reno@videolan.org>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  23  *****************************************************************************/
  24
  25 #include "defs.h"
  26
  27 #include "config.h"
  28 #include "common.h"
  29
  30 #include "threads.h"
  31 #include "mtime.h"
  32
  33 #include "stream_control.h"
  34 #include "input_ext-dec.h"
  35
  36 #include "audio_output.h"
  37
  38 #include "intf_msg.h"
  39 #include "ac3_decoder.h"
  40 #include "ac3_decoder_thread.h"
  41
  42 #include "ac3_internal.h"
  43 #include "ac3_bit_stream.h"
  44
  45 /* Misc LUT */
  46 static const u16 nfchans[] = { 2, 1, 2, 3, 3, 4, 4, 5 };
  47
  48 struct frmsize_s
  49 {
  50     u16 bit_rate;
  51     u16 frm_size[3];
  52 };
  53
  54 static const struct frmsize_s frmsizecod_tbl[] =
  55 {
  56       { 32  ,{64   ,69   ,96   } },
  57       { 32  ,{64   ,70   ,96   } },
  58       { 40  ,{80   ,87   ,120  } },
  59       { 40  ,{80   ,88   ,120  } },
  60       { 48  ,{96   ,104  ,144  } },
  61       { 48  ,{96   ,105  ,144  } },
  62       { 56  ,{112  ,121  ,168  } },
  63       { 56  ,{112  ,122  ,168  } },
  64       { 64  ,{128  ,139  ,192  } },
  65       { 64  ,{128  ,140  ,192  } },
  66       { 80  ,{160  ,174  ,240  } },
  67       { 80  ,{160  ,175  ,240  } },
  68       { 96  ,{192  ,208  ,288  } },
  69       { 96  ,{192  ,209  ,288  } },
  70       { 112 ,{224  ,243  ,336  } },
  71       { 112 ,{224  ,244  ,336  } },
  72       { 128 ,{256  ,278  ,384  } },
  73       { 128 ,{256  ,279  ,384  } },
  74       { 160 ,{320  ,348  ,480  } },
  75       { 160 ,{320  ,349  ,480  } },
  76       { 192 ,{384  ,417  ,576  } },
  77       { 192 ,{384  ,418  ,576  } },
  78       { 224 ,{448  ,487  ,672  } },
  79       { 224 ,{448  ,488  ,672  } },
  80       { 256 ,{512  ,557  ,768  } },
  81       { 256 ,{512  ,558  ,768  } },
  82       { 320 ,{640  ,696  ,960  } },
  83       { 320 ,{640  ,697  ,960  } },
  84       { 384 ,{768  ,835  ,1152 } },
  85       { 384 ,{768  ,836  ,1152 } },
  86       { 448 ,{896  ,975  ,1344 } },
  87       { 448 ,{896  ,976  ,1344 } },
  88       { 512 ,{1024 ,1114 ,1536 } },
  89       { 512 ,{1024 ,1115 ,1536 } },
  90       { 576 ,{1152 ,1253 ,1728 } },
  91       { 576 ,{1152 ,1254 ,1728 } },
  92       { 640 ,{1280 ,1393 ,1920 } },
  93       { 640 ,{1280 ,1394 ,1920 } }};
  94
  95 static const int fscod_tbl[] = {48000, 44100, 32000};
  96
  97 /* Some internal functions */
  98 void parse_bsi_stats (ac3dec_t * p_ac3dec);
  99 void parse_audblk_stats (ac3dec_t * p_ac3dec);
 100
 101 /* Parse a syncinfo structure */
 102 int ac3_sync_frame (ac3dec_t * p_ac3dec, ac3_sync_info_t * p_sync_info)
 103 {
 104     int buf;
 105
 106     p_ac3dec->bit_stream.total_bits_read = 0;
 107     p_ac3dec->bit_stream.i_available = 0;
 108
 109     /* sync word - should be 0x0b77 */
 110     if( (buf =  bitstream_get(&(p_ac3dec->bit_stream),16)) != 0x0b77)
 111     {
 112         return 1;
 113     }
 114
 115     /* Get crc1 - we don't actually use this data though */
 116     bitstream_get(&(p_ac3dec->bit_stream),16);
 117
 118     /* Get the sampling rate */
 119     p_ac3dec->syncinfo.fscod = bitstream_get(&(p_ac3dec->bit_stream),2);
 120
 121     if (p_ac3dec->syncinfo.fscod >= 3)
 122     {
 123         return 1;
 124     }
 125
 126     /* Get the frame size code */
 127     p_ac3dec->syncinfo.frmsizecod = bitstream_get(&(p_ac3dec->bit_stream),6);
 128
 129     if (p_ac3dec->syncinfo.frmsizecod >= 38)
 130     {
 131         return 1;
 132     }
 133
 134     p_sync_info->bit_rate = frmsizecod_tbl[p_ac3dec->syncinfo.frmsizecod].bit_rate;
 135
 136     p_ac3dec->syncinfo.frame_size = frmsizecod_tbl[p_ac3dec->syncinfo.frmsizecod].frm_size[p_ac3dec->syncinfo.fscod];
 137     p_sync_info->frame_size = 2 * p_ac3dec->syncinfo.frame_size;
 138
 139     p_sync_info->sample_rate = fscod_tbl[p_ac3dec->syncinfo.fscod];
 140
 141     return 0;
 142 }
 143
 144 /*
 145  * This routine fills a bsi struct from the AC3 stream
 146  */
 147 int parse_bsi (ac3dec_t * p_ac3dec)
 148 {
 149     /* Check the AC-3 version number */
 150     p_ac3dec->bsi.bsid = bitstream_get(&(p_ac3dec->bit_stream),5);
 151
 152     if (p_ac3dec->bsi.bsid > 8)
 153     {
 154         return 1;
 155     }
 156
 157     /* Get the audio service provided by the stream */
 158     p_ac3dec->bsi.bsmod = bitstream_get(&(p_ac3dec->bit_stream),3);
 159
 160     /* Get the audio coding mode (ie how many channels)*/
 161     p_ac3dec->bsi.acmod = bitstream_get(&(p_ac3dec->bit_stream),3);
 162     /* Predecode the number of full bandwidth channels as we use this
 163      * number a lot */
 164     p_ac3dec->bsi.nfchans = nfchans[p_ac3dec->bsi.acmod];
 165
 166     /* If it is in use, get the centre channel mix level */
 167     if ((p_ac3dec->bsi.acmod & 0x1) && (p_ac3dec->bsi.acmod != 0x1))
 168     {
 169         p_ac3dec->bsi.cmixlev = bitstream_get(&(p_ac3dec->bit_stream),2);
 170     }
 171
 172     /* If it is in use, get the surround channel mix level */
 173     if (p_ac3dec->bsi.acmod & 0x4)
 174     {
 175         p_ac3dec->bsi.surmixlev = bitstream_get(&(p_ac3dec->bit_stream),2);
 176     }
 177
 178     /* Get the dolby surround mode if in 2/0 mode */
 179     if (p_ac3dec->bsi.acmod == 0x2)
 180     {
 181         p_ac3dec->bsi.dsurmod = bitstream_get(&(p_ac3dec->bit_stream),2);
 182     }
 183
 184     /* Is the low frequency effects channel on? */
 185     p_ac3dec->bsi.lfeon = bitstream_get(&(p_ac3dec->bit_stream),1);
 186
 187     /* Get the dialogue normalization level */
 188     p_ac3dec->bsi.dialnorm = bitstream_get(&(p_ac3dec->bit_stream),5);
 189
 190     /* Does compression gain exist? */
 191     if ((p_ac3dec->bsi.compre = bitstream_get(&(p_ac3dec->bit_stream),1)))
 192     {
 193         /* Get compression gain */
 194         p_ac3dec->bsi.compr = bitstream_get(&(p_ac3dec->bit_stream),8);
 195     }
 196
 197     /* Does language code exist? */
 198     if ((p_ac3dec->bsi.langcode = bitstream_get(&(p_ac3dec->bit_stream),1)))
 199     {
 200         /* Get langauge code */
 201         p_ac3dec->bsi.langcod = bitstream_get(&(p_ac3dec->bit_stream),8);
 202     }
 203
 204     /* Does audio production info exist? */
 205     if ((p_ac3dec->bsi.audprodie = bitstream_get(&(p_ac3dec->bit_stream),1)))
 206     {
 207         /* Get mix level */
 208         p_ac3dec->bsi.mixlevel = bitstream_get(&(p_ac3dec->bit_stream),5);
 209
 210         /* Get room type */
 211         p_ac3dec->bsi.roomtyp = bitstream_get(&(p_ac3dec->bit_stream),2);
 212     }
 213
 214     /* If we're in dual mono mode then get some extra info */
 215     if (p_ac3dec->bsi.acmod == 0)
 216     {
 217         /* Get the dialogue normalization level two */
 218         p_ac3dec->bsi.dialnorm2 = bitstream_get(&(p_ac3dec->bit_stream),5);
 219
 220         /* Does compression gain two exist? */
 221         if ((p_ac3dec->bsi.compr2e = bitstream_get(&(p_ac3dec->bit_stream),1)))
 222         {
 223             /* Get compression gain two */
 224             p_ac3dec->bsi.compr2 = bitstream_get(&(p_ac3dec->bit_stream),8);
 225         }
 226
 227         /* Does language code two exist? */
 228         if ((p_ac3dec->bsi.langcod2e = bitstream_get(&(p_ac3dec->bit_stream),1)))
 229         {
 230             /* Get langauge code two */
 231             p_ac3dec->bsi.langcod2 = bitstream_get(&(p_ac3dec->bit_stream),8);
 232         }
 233
 234         /* Does audio production info two exist? */
 235         if ((p_ac3dec->bsi.audprodi2e = bitstream_get(&(p_ac3dec->bit_stream),1)))
 236         {
 237             /* Get mix level two */
 238             p_ac3dec->bsi.mixlevel2 = bitstream_get(&(p_ac3dec->bit_stream),5);
 239
 240             /* Get room type two */
 241             p_ac3dec->bsi.roomtyp2 = bitstream_get(&(p_ac3dec->bit_stream),2);
 242         }
 243     }
 244
 245     /* Get the copyright bit */
 246     p_ac3dec->bsi.copyrightb = bitstream_get(&(p_ac3dec->bit_stream),1);
 247
 248     /* Get the original bit */
 249     p_ac3dec->bsi.origbs = bitstream_get(&(p_ac3dec->bit_stream),1);
 250
 251     /* Does timecode one exist? */
 252     if ((p_ac3dec->bsi.timecod1e = bitstream_get(&(p_ac3dec->bit_stream),1)))
 253     {
 254         p_ac3dec->bsi.timecod1 = bitstream_get(&(p_ac3dec->bit_stream),14);
 255     }
 256
 257     /* Does timecode two exist? */
 258     if ((p_ac3dec->bsi.timecod2e = bitstream_get(&(p_ac3dec->bit_stream),1)))
 259     {
 260         p_ac3dec->bsi.timecod2 = bitstream_get(&(p_ac3dec->bit_stream),14);
 261     }
 262
 263     /* Does addition info exist? */
 264     if ((p_ac3dec->bsi.addbsie = bitstream_get(&(p_ac3dec->bit_stream),1)))
 265     {
 266         u32 i;
 267
 268         /* Get how much info is there */
 269         p_ac3dec->bsi.addbsil = bitstream_get(&(p_ac3dec->bit_stream),6);
 270
 271         /* Get the additional info */
 272         for (i=0;i<(p_ac3dec->bsi.addbsil + 1);i++)
 273         {
 274             p_ac3dec->bsi.addbsi[i] = bitstream_get(&(p_ac3dec->bit_stream),8);
 275         }
 276     }
 277
 278 #ifdef STATS
 279     parse_bsi_stats (p_ac3dec);
 280 #endif
 281
 282     return 0;
 283 }
 284
 285 /* More pain inducing parsing */
 286 int parse_audblk (ac3dec_t * p_ac3dec, int blknum)
 287 {
 288     int i, j;
 289
 290     for (i=0; i < p_ac3dec->bsi.nfchans; i++)
 291     {
 292         /* Is this channel an interleaved 256 + 256 block ? */
 293         p_ac3dec->audblk.blksw[i] = bitstream_get(&(p_ac3dec->bit_stream),1);
 294     }
 295
 296     for (i=0; i < p_ac3dec->bsi.nfchans; i++)
 297     {
 298         /* Should we dither this channel? */
 299         p_ac3dec->audblk.dithflag[i] = bitstream_get(&(p_ac3dec->bit_stream),1);
 300     }
 301
 302     /* Does dynamic range control exist? */
 303     if ((p_ac3dec->audblk.dynrnge = bitstream_get(&(p_ac3dec->bit_stream),1)))
 304     {
 305         /* Get dynamic range info */
 306         p_ac3dec->audblk.dynrng = bitstream_get(&(p_ac3dec->bit_stream),8);
 307     }
 308
 309     /* If we're in dual mono mode then get the second channel DR info */
 310     if (p_ac3dec->bsi.acmod == 0)
 311     {
 312         /* Does dynamic range control two exist? */
 313         if ((p_ac3dec->audblk.dynrng2e = bitstream_get(&(p_ac3dec->bit_stream),1)))
 314         {
 315             /* Get dynamic range info */
 316             p_ac3dec->audblk.dynrng2 = bitstream_get(&(p_ac3dec->bit_stream),8);
 317         }
 318     }
 319
 320     /* Does coupling strategy exist? */
 321     p_ac3dec->audblk.cplstre = bitstream_get(&(p_ac3dec->bit_stream),1);
 322
 323     if ((!blknum) && (!p_ac3dec->audblk.cplstre))
 324     {
 325         return 1;
 326     }
 327
 328     if (p_ac3dec->audblk.cplstre)
 329     {
 330         /* Is coupling turned on? */
 331         if ((p_ac3dec->audblk.cplinu = bitstream_get(&(p_ac3dec->bit_stream),1)))
 332         {
 333             int nb_coupled_channels;
 334
 335             nb_coupled_channels = 0;
 336             for (i=0; i < p_ac3dec->bsi.nfchans; i++)
 337             {
 338                 p_ac3dec->audblk.chincpl[i] = bitstream_get(&(p_ac3dec->bit_stream),1);
 339                 if (p_ac3dec->audblk.chincpl[i])
 340                 {
 341                     nb_coupled_channels++;
 342                 }
 343             }
 344             if (nb_coupled_channels < 2)
 345             {
 346                 return 1;
 347             }
 348
 349             if (p_ac3dec->bsi.acmod == 0x2)
 350             {
 351                 p_ac3dec->audblk.phsflginu = bitstream_get(&(p_ac3dec->bit_stream),1);
 352             }
 353             p_ac3dec->audblk.cplbegf = bitstream_get(&(p_ac3dec->bit_stream),4);
 354             p_ac3dec->audblk.cplendf = bitstream_get(&(p_ac3dec->bit_stream),4);
 355
 356             if (p_ac3dec->audblk.cplbegf > p_ac3dec->audblk.cplendf + 2)
 357             {
 358                 return 1;
 359             }
 360
 361             p_ac3dec->audblk.ncplsubnd = (p_ac3dec->audblk.cplendf + 2) - p_ac3dec->audblk.cplbegf + 1;
 362
 363             /* Calculate the start and end bins of the coupling channel */
 364             p_ac3dec->audblk.cplstrtmant = (p_ac3dec->audblk.cplbegf * 12) + 37 ;
 365             p_ac3dec->audblk.cplendmant = ((p_ac3dec->audblk.cplendf + 3) * 12) + 37;
 366
 367             /* The number of combined subbands is ncplsubnd minus each combined
 368              * band */
 369             p_ac3dec->audblk.ncplbnd = p_ac3dec->audblk.ncplsubnd;
 370
 371             for (i=1; i< p_ac3dec->audblk.ncplsubnd; i++)
 372             {
 373                 p_ac3dec->audblk.cplbndstrc[i] = bitstream_get(&(p_ac3dec->bit_stream),1);
 374                 p_ac3dec->audblk.ncplbnd -= p_ac3dec->audblk.cplbndstrc[i];
 375             }
 376         }
 377     }
 378
 379     if (p_ac3dec->audblk.cplinu)
 380     {
 381         /* Loop through all the channels and get their coupling co-ords */
 382         for (i=0; i < p_ac3dec->bsi.nfchans;i++)
 383         {
 384             if (!p_ac3dec->audblk.chincpl[i])
 385             {
 386                 continue;
 387             }
 388
 389             /* Is there new coupling co-ordinate info? */
 390             p_ac3dec->audblk.cplcoe[i] = bitstream_get(&(p_ac3dec->bit_stream),1);
 391
 392             if ((!blknum) && (!p_ac3dec->audblk.cplcoe[i]))
 393             {
 394                 return 1;
 395             }
 396
 397             if (p_ac3dec->audblk.cplcoe[i])
 398             {
 399                 p_ac3dec->audblk.mstrcplco[i] = bitstream_get(&(p_ac3dec->bit_stream),2);
 400                 for (j=0;j < p_ac3dec->audblk.ncplbnd; j++)
 401                 {
 402                     p_ac3dec->audblk.cplcoexp[i][j] = bitstream_get(&(p_ac3dec->bit_stream),4);
 403                     p_ac3dec->audblk.cplcomant[i][j] = bitstream_get(&(p_ac3dec->bit_stream),4);
 404                 }
 405             }
 406         }
 407
 408         /* If we're in dual mono mode, there's going to be some phase info */
 409         if ((p_ac3dec->bsi.acmod == 0x2) && p_ac3dec->audblk.phsflginu &&
 410            (p_ac3dec->audblk.cplcoe[0] || p_ac3dec->audblk.cplcoe[1]))
 411         {
 412             for (j=0; j < p_ac3dec->audblk.ncplbnd; j++)
 413             {
 414                 p_ac3dec->audblk.phsflg[j] = bitstream_get(&(p_ac3dec->bit_stream),1);
 415             }
 416
 417         }
 418     }
 419
 420     /* If we're in dual mono mode, there may be a rematrix strategy */
 421     if (p_ac3dec->bsi.acmod == 0x2)
 422     {
 423         p_ac3dec->audblk.rematstr = bitstream_get(&(p_ac3dec->bit_stream),1);
 424
 425         if ((!blknum) && (!p_ac3dec->audblk.rematstr))
 426         {
 427             return 1;
 428         }
 429
 430         if (p_ac3dec->audblk.rematstr)
 431         {
 432             if (p_ac3dec->audblk.cplinu == 0)
 433             {
 434                 for (i = 0; i < 4; i++)
 435                 {
 436                     p_ac3dec->audblk.rematflg[i] = bitstream_get(&(p_ac3dec->bit_stream),1);
 437                 }
 438             }
 439             if ((p_ac3dec->audblk.cplbegf > 2) && p_ac3dec->audblk.cplinu)
 440             {
 441                 for (i = 0; i < 4; i++)
 442                 {
 443                     p_ac3dec->audblk.rematflg[i] = bitstream_get(&(p_ac3dec->bit_stream),1);
 444                 }
 445             }
 446             if ((p_ac3dec->audblk.cplbegf <= 2) && p_ac3dec->audblk.cplinu)
 447             {
 448                 for (i = 0; i < 3; i++)
 449                 {
 450                     p_ac3dec->audblk.rematflg[i] = bitstream_get(&(p_ac3dec->bit_stream),1);
 451                 }
 452             }
 453             if ((p_ac3dec->audblk.cplbegf == 0) && p_ac3dec->audblk.cplinu)
 454             {
 455                 for (i = 0; i < 2; i++)
 456                 {
 457                     p_ac3dec->audblk.rematflg[i] = bitstream_get(&(p_ac3dec->bit_stream),1);
 458                 }
 459             }
 460         }
 461     }
 462
 463     if (p_ac3dec->audblk.cplinu)
 464     {
 465         /* Get the coupling channel exponent strategy */
 466         p_ac3dec->audblk.cplexpstr = bitstream_get(&(p_ac3dec->bit_stream),2);
 467
 468         if ((!blknum) && (p_ac3dec->audblk.cplexpstr == EXP_REUSE))
 469         {
 470             return 1;
 471         }
 472
 473         if (p_ac3dec->audblk.cplexpstr==0)
 474         {
 475             p_ac3dec->audblk.ncplgrps = 0;
 476         }
 477         else
 478         {
 479             p_ac3dec->audblk.ncplgrps = (p_ac3dec->audblk.cplendmant - p_ac3dec->audblk.cplstrtmant) /
 480                 (3 << (p_ac3dec->audblk.cplexpstr-1));
 481         }
 482
 483     }
 484
 485     for (i = 0; i < p_ac3dec->bsi.nfchans; i++)
 486     {
 487         p_ac3dec->audblk.chexpstr[i] = bitstream_get(&(p_ac3dec->bit_stream),2);
 488
 489         if ((!blknum) && (p_ac3dec->audblk.chexpstr[i] == EXP_REUSE))
 490         {
 491             return 1;
 492         }
 493     }
 494
 495     /* Get the exponent strategy for lfe channel */
 496     if (p_ac3dec->bsi.lfeon)
 497     {
 498         p_ac3dec->audblk.lfeexpstr = bitstream_get(&(p_ac3dec->bit_stream),1);
 499
 500         if ((!blknum) && (p_ac3dec->audblk.lfeexpstr == EXP_REUSE))
 501         {
 502             return 1;
 503         }
 504     }
 505
 506     /* Determine the bandwidths of all the fbw channels */
 507     for (i = 0; i < p_ac3dec->bsi.nfchans; i++)
 508     {
 509         u16 grp_size;
 510
 511         if (p_ac3dec->audblk.chexpstr[i] != EXP_REUSE)
 512         {
 513             if (p_ac3dec->audblk.cplinu && p_ac3dec->audblk.chincpl[i])
 514             {
 515                 p_ac3dec->audblk.endmant[i] = p_ac3dec->audblk.cplstrtmant;
 516             }
 517             else
 518             {
 519                 p_ac3dec->audblk.chbwcod[i] = bitstream_get(&(p_ac3dec->bit_stream),6);
 520
 521                 if (p_ac3dec->audblk.chbwcod[i] > 60)
 522                 {
 523                     return 1;
 524                 }
 525
 526                 p_ac3dec->audblk.endmant[i] = ((p_ac3dec->audblk.chbwcod[i] + 12) * 3) + 37;
 527             }
 528
 529             /* Calculate the number of exponent groups to fetch */
 530             grp_size =  3 * (1 << (p_ac3dec->audblk.chexpstr[i] - 1));
 531             p_ac3dec->audblk.nchgrps[i] = (p_ac3dec->audblk.endmant[i] - 1 + (grp_size - 3)) / grp_size;
 532         }
 533     }
 534
 535     /* Get the coupling exponents if they exist */
 536     if (p_ac3dec->audblk.cplinu && (p_ac3dec->audblk.cplexpstr != EXP_REUSE))
 537     {
 538         p_ac3dec->audblk.cplabsexp = bitstream_get(&(p_ac3dec->bit_stream),4);
 539         for (i=0; i< p_ac3dec->audblk.ncplgrps;i++)
 540         {
 541             p_ac3dec->audblk.cplexps[i] = bitstream_get(&(p_ac3dec->bit_stream),7);
 542
 543             if (p_ac3dec->audblk.cplexps[i] >= 125)
 544             {
 545                 return 1;
 546             }
 547         }
 548     }
 549
 550     /* Get the fwb channel exponents */
 551     for (i=0; i < p_ac3dec->bsi.nfchans; i++)
 552     {
 553         if (p_ac3dec->audblk.chexpstr[i] != EXP_REUSE)
 554         {
 555             p_ac3dec->audblk.exps[i][0] = bitstream_get(&(p_ac3dec->bit_stream),4);
 556             for (j=1; j<=p_ac3dec->audblk.nchgrps[i];j++)
 557             {
 558                 p_ac3dec->audblk.exps[i][j] = bitstream_get(&(p_ac3dec->bit_stream),7);
 559                 if (p_ac3dec->audblk.exps[i][j] >= 125)
 560                 {
 561                     return 1;
 562                 }
 563             }
 564             p_ac3dec->audblk.gainrng[i] = bitstream_get(&(p_ac3dec->bit_stream),2);
 565         }
 566     }
 567
 568     /* Get the lfe channel exponents */
 569     if (p_ac3dec->bsi.lfeon && (p_ac3dec->audblk.lfeexpstr != EXP_REUSE))
 570     {
 571         p_ac3dec->audblk.lfeexps[0] = bitstream_get(&(p_ac3dec->bit_stream),4);
 572         p_ac3dec->audblk.lfeexps[1] = bitstream_get(&(p_ac3dec->bit_stream),7);
 573         if (p_ac3dec->audblk.lfeexps[1] >= 125)
 574         {
 575             return 1;
 576         }
 577         p_ac3dec->audblk.lfeexps[2] = bitstream_get(&(p_ac3dec->bit_stream),7);
 578         if (p_ac3dec->audblk.lfeexps[2] >= 125)
 579         {
 580             return 1;
 581         }
 582     }
 583
 584     /* Get the parametric bit allocation parameters */
 585     p_ac3dec->audblk.baie = bitstream_get(&(p_ac3dec->bit_stream),1);
 586
 587     if ((!blknum) && (!p_ac3dec->audblk.baie))
 588     {
 589         return 1;
 590     }
 591
 592     if (p_ac3dec->audblk.baie)
 593     {
 594         p_ac3dec->audblk.sdcycod = bitstream_get(&(p_ac3dec->bit_stream),2);
 595         p_ac3dec->audblk.fdcycod = bitstream_get(&(p_ac3dec->bit_stream),2);
 596         p_ac3dec->audblk.sgaincod = bitstream_get(&(p_ac3dec->bit_stream),2);
 597         p_ac3dec->audblk.dbpbcod = bitstream_get(&(p_ac3dec->bit_stream),2);
 598         p_ac3dec->audblk.floorcod = bitstream_get(&(p_ac3dec->bit_stream),3);
 599     }
 600
 601     /* Get the SNR off set info if it exists */
 602     p_ac3dec->audblk.snroffste = bitstream_get(&(p_ac3dec->bit_stream),1);
 603     if ((!blknum) && (!p_ac3dec->audblk.snroffste))
 604     {
 605         return 1;
 606     }
 607
 608     if (p_ac3dec->audblk.snroffste)
 609     {
 610         p_ac3dec->audblk.csnroffst = bitstream_get(&(p_ac3dec->bit_stream),6);
 611
 612         if (p_ac3dec->audblk.cplinu)
 613         {
 614             p_ac3dec->audblk.cplfsnroffst = bitstream_get(&(p_ac3dec->bit_stream),4);
 615             p_ac3dec->audblk.cplfgaincod = bitstream_get(&(p_ac3dec->bit_stream),3);
 616         }
 617
 618         for (i = 0;i < p_ac3dec->bsi.nfchans; i++)
 619         {
 620             p_ac3dec->audblk.fsnroffst[i] = bitstream_get(&(p_ac3dec->bit_stream),4);
 621             p_ac3dec->audblk.fgaincod[i] = bitstream_get(&(p_ac3dec->bit_stream),3);
 622         }
 623         if (p_ac3dec->bsi.lfeon)
 624         {
 625             p_ac3dec->audblk.lfefsnroffst = bitstream_get(&(p_ac3dec->bit_stream),4);
 626             p_ac3dec->audblk.lfefgaincod = bitstream_get(&(p_ac3dec->bit_stream),3);
 627         }
 628     }
 629
 630     /* Get coupling leakage info if it exists */
 631     if (p_ac3dec->audblk.cplinu)
 632     {
 633         p_ac3dec->audblk.cplleake = bitstream_get(&(p_ac3dec->bit_stream),1);
 634         if ((!blknum) && (!p_ac3dec->audblk.cplleake))
 635         {
 636             return 1;
 637         }
 638
 639         if (p_ac3dec->audblk.cplleake)
 640         {
 641             p_ac3dec->audblk.cplfleak = bitstream_get(&(p_ac3dec->bit_stream),3);
 642             p_ac3dec->audblk.cplsleak = bitstream_get(&(p_ac3dec->bit_stream),3);
 643         }
 644     }
 645
 646     /* Get the delta bit alloaction info */
 647     p_ac3dec->audblk.deltbaie = bitstream_get(&(p_ac3dec->bit_stream),1);
 648
 649     if (p_ac3dec->audblk.deltbaie)
 650     {
 651         if (p_ac3dec->audblk.cplinu)
 652         {
 653             p_ac3dec->audblk.cpldeltbae = bitstream_get(&(p_ac3dec->bit_stream),2);
 654             if (p_ac3dec->audblk.cpldeltbae == 3)
 655             {
 656                 return 1;
 657             }
 658         }
 659
 660         for (i = 0;i < p_ac3dec->bsi.nfchans; i++)
 661         {
 662             p_ac3dec->audblk.deltbae[i] = bitstream_get(&(p_ac3dec->bit_stream),2);
 663             if (p_ac3dec->audblk.deltbae[i] == 3)
 664             {
 665                 return 1;
 666             }
 667         }
 668
 669         if (p_ac3dec->audblk.cplinu && (p_ac3dec->audblk.cpldeltbae == DELTA_BIT_NEW))
 670         {
 671             p_ac3dec->audblk.cpldeltnseg = bitstream_get(&(p_ac3dec->bit_stream),3);
 672             for (i = 0;i < p_ac3dec->audblk.cpldeltnseg + 1; i++)
 673             {
 674                 p_ac3dec->audblk.cpldeltoffst[i] = bitstream_get(&(p_ac3dec->bit_stream),5);
 675                 p_ac3dec->audblk.cpldeltlen[i] = bitstream_get(&(p_ac3dec->bit_stream),4);
 676                 p_ac3dec->audblk.cpldeltba[i] = bitstream_get(&(p_ac3dec->bit_stream),3);
 677             }
 678         }
 679
 680         for (i = 0; i < p_ac3dec->bsi.nfchans; i++)
 681         {
 682             if (p_ac3dec->audblk.deltbae[i] == DELTA_BIT_NEW)
 683             {
 684                 p_ac3dec->audblk.deltnseg[i] = bitstream_get(&(p_ac3dec->bit_stream),3);
 685 //                if (p_ac3dec->audblk.deltnseg[i] >= 8)
 686 //                    fprintf (stderr, "parse debug: p_ac3dec->audblk.deltnseg[%i] == %i\n", i, p_ac3dec->audblk.deltnseg[i]);
 687                 for (j = 0; j < p_ac3dec->audblk.deltnseg[i] + 1; j++)
 688                 {
 689                     p_ac3dec->audblk.deltoffst[i][j] = bitstream_get(&(p_ac3dec->bit_stream),5);
 690                     p_ac3dec->audblk.deltlen[i][j] = bitstream_get(&(p_ac3dec->bit_stream),4);
 691                     p_ac3dec->audblk.deltba[i][j] = bitstream_get(&(p_ac3dec->bit_stream),3);
 692                 }
 693             }
 694         }
 695     }
 696
 697     /* Check to see if there's any dummy info to get */
 698     p_ac3dec->audblk.skiple = bitstream_get(&(p_ac3dec->bit_stream),1);
 699
 700     if (p_ac3dec->audblk.skiple)
 701     {
 702         p_ac3dec->audblk.skipl = bitstream_get(&(p_ac3dec->bit_stream),9);
 703
 704         for (i = 0; i < p_ac3dec->audblk.skipl ; i++)
 705         {
 706             bitstream_get(&(p_ac3dec->bit_stream),8);
 707         }
 708     }
 709
 710 #ifdef STATS
 711 //    parse_audblk_stats(p_ac3dec);
 712 #endif
 713
 714     return 0;
 715 }
 716
 717 void parse_auxdata (ac3dec_t * p_ac3dec)
 718 {
 719     int i;
 720     int skip_length;
 721
 722     skip_length = (p_ac3dec->syncinfo.frame_size * 16) - p_ac3dec->bit_stream.total_bits_read - 17 - 1;
 723
 724     for (i = 0; i < skip_length; i++)
 725     {
 726         bitstream_get(&(p_ac3dec->bit_stream),1);
 727     }
 728
 729     /* get the auxdata exists bit */
 730     bitstream_get(&(p_ac3dec->bit_stream),1);
 731
 732     /* Skip the CRC reserved bit */
 733     bitstream_get(&(p_ac3dec->bit_stream),1);
 734
 735     /* Get the crc */
 736     bitstream_get(&(p_ac3dec->bit_stream),16);
 737 }
 738
 739 void parse_bsi_stats (ac3dec_t * p_ac3dec) /*Some stats */
 740 {
 741     struct mixlev_s
 742     {
 743             float clev;
 744         char *desc;
 745     };
 746     static const char *service_ids[8] =
 747     {
 748         "CM","ME","VI","HI",
 749         "D", "C","E", "VO"
 750     };
 751 /*
 752     static const struct mixlev_s cmixlev_tbl[4] =
 753     {
 754         {0.707, "(-3.0 dB)"}, {0.595, "(-4.5 dB)"},
 755         {0.500, "(-6.0 dB)"}, {1.0,  "Invalid"}
 756     };
 757     static const struct mixlev_s smixlev_tbl[4] =
 758     {
 759         {0.707, "(-3.0 dB)"}, {0.500, "(-6.0 dB)"},
 760         {  0.0,   "off    "}, {  1.0, "Invalid"}
 761     };
 762  */
 763
 764     static int  i;
 765
 766     if ( !i )
 767     {
 768 /*      if ((p_ac3dec->bsi.acmod & 0x1) && (p_ac3dec->bsi.acmod != 0x1))
 769                 printf("CentreMixLevel %s ",cmixlev_tbl[p_ac3dec->bsi.cmixlev].desc);
 770         if (p_ac3dec->bsi.acmod & 0x4)
 771                 printf("SurMixLevel %s",smixlev_tbl[p_ac3dec->bsi.cmixlev].desc);
 772  */
 773         intf_Msg ( "(ac3dec_parsebsi) %s %d.%d Mode",
 774                 service_ids[p_ac3dec->bsi.bsmod],
 775                 p_ac3dec->bsi.nfchans,p_ac3dec->bsi.lfeon);
 776     }
 777     i++;
 778
 779     if ( i > 100 )
 780         i = 0;
 781 }
 782
 783 void parse_audblk_stats (ac3dec_t * p_ac3dec)
 784 {
 785     char *exp_strat_tbl[4] = {"R   ","D15 ","D25 ","D45 "};
 786     u32 i;
 787
 788         intf_ErrMsg ("(ac3dec_parseaudblk) ");
 789         intf_ErrMsg ("%s ",p_ac3dec->audblk.cplinu ? "cpl on" : "cpl off");
 790         intf_ErrMsg ("%s ",p_ac3dec->audblk.baie? "bai" : " ");
 791         intf_ErrMsg ("%s ",p_ac3dec->audblk.snroffste? "snroffst" : " ");
 792         intf_ErrMsg ("%s ",p_ac3dec->audblk.deltbaie? "deltba" : " ");
 793         intf_ErrMsg ("%s ",p_ac3dec->audblk.phsflginu? "phsflg" : " ");
 794         intf_ErrMsg ("(%s %s %s %s %s) ",exp_strat_tbl[p_ac3dec->audblk.chexpstr[0]],
 795                 exp_strat_tbl[p_ac3dec->audblk.chexpstr[1]],exp_strat_tbl[p_ac3dec->audblk.chexpstr[2]],
 796                 exp_strat_tbl[p_ac3dec->audblk.chexpstr[3]],exp_strat_tbl[p_ac3dec->audblk.chexpstr[4]]);
 797         intf_ErrMsg ("[");
 798         for(i=0;i<p_ac3dec->bsi.nfchans;i++)
 799                 intf_ErrMsg ("%1d",p_ac3dec->audblk.blksw[i]);
 800         intf_ErrMsg ("]");
 801
 802         intf_ErrMsg ("\n");
 803 }