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