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