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