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-2001 VideoLAN
   5  * $Id: ac3_parse.c,v 1.8 2002/03/06 03:27:17 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 /*****************************************************************************
  27  * Preamble
  28  *****************************************************************************/
  29 #include <string.h>                                              /* memset() */
  30
  31 #include <videolan/vlc.h>
  32
  33 #include "audio_output.h"
  34
  35 #include "stream_control.h"
  36 #include "input_ext-dec.h"
  37
  38 #include "ac3_imdct.h"
  39 #include "ac3_downmix.h"
  40 #include "ac3_decoder.h"
  41 #include "ac3_adec.h"                                     /* ac3dec_thread_t */
  42
  43 #include "ac3_internal.h"                                       /* EXP_REUSE */
  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 static void parse_bsi_stats (ac3dec_t * p_ac3dec);
  99 static 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     if( p_main->b_stats )
 302     {
 303         parse_bsi_stats (p_ac3dec);
 304     }
 305
 306     return 0;
 307 }
 308
 309 /* More pain inducing parsing */
 310 int parse_audblk (ac3dec_t * p_ac3dec, int blknum)
 311 {
 312     int i, j;
 313
 314     for (i=0; i < p_ac3dec->bsi.nfchans; i++)
 315     {
 316         /* Is this channel an interleaved 256 + 256 block ? */
 317         p_ac3dec->audblk.blksw[i] = GetBits (&p_ac3dec->bit_stream,1);
 318     }
 319
 320     for (i=0; i < p_ac3dec->bsi.nfchans; i++)
 321     {
 322         /* Should we dither this channel? */
 323         p_ac3dec->audblk.dithflag[i] = GetBits (&p_ac3dec->bit_stream,1);
 324     }
 325
 326     /* Does dynamic range control exist? */
 327     if ((p_ac3dec->audblk.dynrnge = GetBits (&p_ac3dec->bit_stream,1)))
 328     {
 329         /* Get dynamic range info */
 330         p_ac3dec->audblk.dynrng = GetBits (&p_ac3dec->bit_stream,8);
 331         p_ac3dec->total_bits_read += 8;
 332     }
 333
 334     /* If we're in dual mono mode then get the second channel DR info */
 335     if (p_ac3dec->bsi.acmod == 0)
 336     {
 337         /* Does dynamic range control two exist? */
 338         if ((p_ac3dec->audblk.dynrng2e = GetBits (&p_ac3dec->bit_stream,1)))
 339         {
 340             /* Get dynamic range info */
 341             p_ac3dec->audblk.dynrng2 = GetBits (&p_ac3dec->bit_stream,8);
 342             p_ac3dec->total_bits_read += 8;
 343         }
 344         p_ac3dec->total_bits_read += 1;
 345     }
 346
 347     /* Does coupling strategy exist? */
 348     p_ac3dec->audblk.cplstre = GetBits (&p_ac3dec->bit_stream,1);
 349     p_ac3dec->total_bits_read += 2 + 2 * p_ac3dec->bsi.nfchans;
 350
 351     if ((!blknum) && (!p_ac3dec->audblk.cplstre))
 352     {
 353         return 1;
 354     }
 355
 356     if (p_ac3dec->audblk.cplstre)
 357     {
 358         /* Is coupling turned on? */
 359         if ((p_ac3dec->audblk.cplinu = GetBits (&p_ac3dec->bit_stream,1)))
 360         {
 361             int nb_coupled_channels;
 362
 363             nb_coupled_channels = 0;
 364             for (i=0; i < p_ac3dec->bsi.nfchans; i++)
 365             {
 366                 p_ac3dec->audblk.chincpl[i] = GetBits (&p_ac3dec->bit_stream,1);
 367                 if (p_ac3dec->audblk.chincpl[i])
 368                 {
 369                     nb_coupled_channels++;
 370                 }
 371             }
 372             p_ac3dec->total_bits_read += p_ac3dec->bsi.nfchans;
 373
 374             if (nb_coupled_channels < 2)
 375             {
 376                 return 1;
 377             }
 378
 379             if (p_ac3dec->bsi.acmod == 0x2)
 380             {
 381                 p_ac3dec->audblk.phsflginu = GetBits (&p_ac3dec->bit_stream,1);
 382                 p_ac3dec->total_bits_read += 1;
 383             }
 384             p_ac3dec->audblk.cplbegf = GetBits (&p_ac3dec->bit_stream,4);
 385             p_ac3dec->audblk.cplendf = GetBits (&p_ac3dec->bit_stream,4);
 386             p_ac3dec->total_bits_read += 8;
 387
 388             if (p_ac3dec->audblk.cplbegf > p_ac3dec->audblk.cplendf + 2)
 389             {
 390                 return 1;
 391             }
 392
 393             p_ac3dec->audblk.ncplsubnd = (p_ac3dec->audblk.cplendf + 2) - p_ac3dec->audblk.cplbegf + 1;
 394
 395             /* Calculate the start and end bins of the coupling channel */
 396             p_ac3dec->audblk.cplstrtmant = (p_ac3dec->audblk.cplbegf * 12) + 37 ;
 397             p_ac3dec->audblk.cplendmant = ((p_ac3dec->audblk.cplendf + 3) * 12) + 37;
 398
 399             /* The number of combined subbands is ncplsubnd minus each combined
 400              * band */
 401             p_ac3dec->audblk.ncplbnd = p_ac3dec->audblk.ncplsubnd;
 402
 403             for (i=1; i< p_ac3dec->audblk.ncplsubnd; i++)
 404             {
 405                 p_ac3dec->audblk.cplbndstrc[i] = GetBits (&p_ac3dec->bit_stream,1);
 406                 p_ac3dec->audblk.ncplbnd -= p_ac3dec->audblk.cplbndstrc[i];
 407             }
 408             p_ac3dec->total_bits_read += p_ac3dec->audblk.ncplsubnd - 1;
 409         }
 410         p_ac3dec->total_bits_read += 1;
 411     }
 412
 413     if (p_ac3dec->audblk.cplinu)
 414     {
 415         /* Loop through all the channels and get their coupling co-ords */
 416         for (i=0; i < p_ac3dec->bsi.nfchans;i++)
 417         {
 418             if (!p_ac3dec->audblk.chincpl[i])
 419             {
 420                 continue;
 421             }
 422
 423             /* Is there new coupling co-ordinate info? */
 424             p_ac3dec->audblk.cplcoe[i] = GetBits (&p_ac3dec->bit_stream,1);
 425
 426             if ((!blknum) && (!p_ac3dec->audblk.cplcoe[i]))
 427             {
 428                 return 1;
 429             }
 430
 431             if (p_ac3dec->audblk.cplcoe[i])
 432             {
 433                 p_ac3dec->audblk.mstrcplco[i] = GetBits (&p_ac3dec->bit_stream,2);
 434                 p_ac3dec->total_bits_read += 2;
 435                 for (j=0;j < p_ac3dec->audblk.ncplbnd; j++)
 436                 {
 437                     p_ac3dec->audblk.cplcoexp[i][j] = GetBits (&p_ac3dec->bit_stream,4);
 438                     p_ac3dec->audblk.cplcomant[i][j] = GetBits (&p_ac3dec->bit_stream,4);
 439                 }
 440                 p_ac3dec->total_bits_read += 8 * p_ac3dec->audblk.ncplbnd;
 441             }
 442         }
 443         p_ac3dec->total_bits_read += p_ac3dec->bsi.nfchans;
 444
 445         /* If we're in dual mono mode, there's going to be some phase info */
 446         if ((p_ac3dec->bsi.acmod == 0x2) && p_ac3dec->audblk.phsflginu &&
 447            (p_ac3dec->audblk.cplcoe[0] || p_ac3dec->audblk.cplcoe[1]))
 448         {
 449             for (j=0; j < p_ac3dec->audblk.ncplbnd; j++)
 450             {
 451                 p_ac3dec->audblk.phsflg[j] = GetBits (&p_ac3dec->bit_stream,1);
 452             }
 453             p_ac3dec->total_bits_read += p_ac3dec->audblk.ncplbnd;
 454
 455         }
 456     }
 457
 458     /* If we're in dual mono mode, there may be a rematrix strategy */
 459     if (p_ac3dec->bsi.acmod == 0x2)
 460     {
 461         p_ac3dec->audblk.rematstr = GetBits (&p_ac3dec->bit_stream,1);
 462         p_ac3dec->total_bits_read += 1;
 463
 464         if ((!blknum) && (!p_ac3dec->audblk.rematstr))
 465         {
 466             return 1;
 467         }
 468
 469         if (p_ac3dec->audblk.rematstr)
 470         {
 471             if (p_ac3dec->audblk.cplinu == 0)
 472             {
 473                 for (i = 0; i < 4; i++)
 474                 {
 475                     p_ac3dec->audblk.rematflg[i] = GetBits (&p_ac3dec->bit_stream,1);
 476                 }
 477                 p_ac3dec->total_bits_read += 4;
 478             }
 479             if ((p_ac3dec->audblk.cplbegf > 2) && p_ac3dec->audblk.cplinu)
 480             {
 481                 for (i = 0; i < 4; i++)
 482                 {
 483                     p_ac3dec->audblk.rematflg[i] = GetBits (&p_ac3dec->bit_stream,1);
 484                 }
 485                 p_ac3dec->total_bits_read += 4;
 486             }
 487             if ((p_ac3dec->audblk.cplbegf <= 2) && p_ac3dec->audblk.cplinu)
 488             {
 489                 for (i = 0; i < 3; i++)
 490                 {
 491                     p_ac3dec->audblk.rematflg[i] = GetBits (&p_ac3dec->bit_stream,1);
 492                 }
 493                 p_ac3dec->total_bits_read += 3;
 494             }
 495             if ((p_ac3dec->audblk.cplbegf == 0) && p_ac3dec->audblk.cplinu)
 496             {
 497                 for (i = 0; i < 2; i++)
 498                 {
 499                     p_ac3dec->audblk.rematflg[i] = GetBits (&p_ac3dec->bit_stream,1);
 500                 }
 501                 p_ac3dec->total_bits_read += 2;
 502             }
 503         }
 504     }
 505
 506     if (p_ac3dec->audblk.cplinu)
 507     {
 508         /* Get the coupling channel exponent strategy */
 509         p_ac3dec->audblk.cplexpstr = GetBits (&p_ac3dec->bit_stream,2);
 510         p_ac3dec->total_bits_read += 2;
 511
 512         if ((!blknum) && (p_ac3dec->audblk.cplexpstr == EXP_REUSE))
 513         {
 514             return 1;
 515         }
 516
 517         if (p_ac3dec->audblk.cplexpstr==0)
 518         {
 519             p_ac3dec->audblk.ncplgrps = 0;
 520         }
 521         else
 522         {
 523             p_ac3dec->audblk.ncplgrps = (p_ac3dec->audblk.cplendmant - p_ac3dec->audblk.cplstrtmant) /
 524                 (3 << (p_ac3dec->audblk.cplexpstr-1));
 525         }
 526
 527     }
 528
 529     for (i = 0; i < p_ac3dec->bsi.nfchans; i++)
 530     {
 531         p_ac3dec->audblk.chexpstr[i] = GetBits (&p_ac3dec->bit_stream,2);
 532         p_ac3dec->total_bits_read += 2;
 533
 534         if ((!blknum) && (p_ac3dec->audblk.chexpstr[i] == EXP_REUSE))
 535         {
 536             return 1;
 537         }
 538     }
 539
 540     /* Get the exponent strategy for lfe channel */
 541     if (p_ac3dec->bsi.lfeon)
 542     {
 543         p_ac3dec->audblk.lfeexpstr = GetBits (&p_ac3dec->bit_stream,1);
 544         p_ac3dec->total_bits_read += 1;
 545
 546         if ((!blknum) && (p_ac3dec->audblk.lfeexpstr == EXP_REUSE))
 547         {
 548             return 1;
 549         }
 550     }
 551
 552     /* Determine the bandwidths of all the fbw channels */
 553     for (i = 0; i < p_ac3dec->bsi.nfchans; i++)
 554     {
 555         u16 grp_size;
 556
 557         if (p_ac3dec->audblk.chexpstr[i] != EXP_REUSE)
 558         {
 559             if (p_ac3dec->audblk.cplinu && p_ac3dec->audblk.chincpl[i])
 560             {
 561                 p_ac3dec->audblk.endmant[i] = p_ac3dec->audblk.cplstrtmant;
 562             }
 563             else
 564             {
 565                 p_ac3dec->audblk.chbwcod[i] = GetBits (&p_ac3dec->bit_stream,6);
 566                 p_ac3dec->total_bits_read += 6;
 567
 568                 if (p_ac3dec->audblk.chbwcod[i] > 60)
 569                 {
 570                     return 1;
 571                 }
 572
 573                 p_ac3dec->audblk.endmant[i] = ((p_ac3dec->audblk.chbwcod[i] + 12) * 3) + 37;
 574             }
 575
 576             /* Calculate the number of exponent groups to fetch */
 577             grp_size =  3 * (1 << (p_ac3dec->audblk.chexpstr[i] - 1));
 578             p_ac3dec->audblk.nchgrps[i] = (p_ac3dec->audblk.endmant[i] - 1 + (grp_size - 3)) / grp_size;
 579         }
 580     }
 581
 582     /* Get the coupling exponents if they exist */
 583     if (p_ac3dec->audblk.cplinu && (p_ac3dec->audblk.cplexpstr != EXP_REUSE))
 584     {
 585         p_ac3dec->audblk.cplabsexp = GetBits (&p_ac3dec->bit_stream,4);
 586         p_ac3dec->total_bits_read += 4;
 587         for (i=0; i< p_ac3dec->audblk.ncplgrps;i++)
 588         {
 589             p_ac3dec->audblk.cplexps[i] = GetBits (&p_ac3dec->bit_stream,7);
 590             p_ac3dec->total_bits_read += 7;
 591
 592             if (p_ac3dec->audblk.cplexps[i] >= 125)
 593             {
 594                 return 1;
 595             }
 596         }
 597     }
 598
 599     /* Get the fwb channel exponents */
 600     for (i=0; i < p_ac3dec->bsi.nfchans; i++)
 601     {
 602         if (p_ac3dec->audblk.chexpstr[i] != EXP_REUSE)
 603         {
 604             p_ac3dec->audblk.exps[i][0] = GetBits (&p_ac3dec->bit_stream,4);
 605             p_ac3dec->total_bits_read += 4;
 606             for (j=1; j<=p_ac3dec->audblk.nchgrps[i];j++)
 607             {
 608                 p_ac3dec->audblk.exps[i][j] = GetBits (&p_ac3dec->bit_stream,7);
 609                 p_ac3dec->total_bits_read += 7;
 610                 if (p_ac3dec->audblk.exps[i][j] >= 125)
 611                 {
 612                     return 1;
 613                 }
 614             }
 615             p_ac3dec->audblk.gainrng[i] = GetBits (&p_ac3dec->bit_stream,2);
 616             p_ac3dec->total_bits_read += 2;
 617         }
 618     }
 619
 620     /* Get the lfe channel exponents */
 621     if (p_ac3dec->bsi.lfeon && (p_ac3dec->audblk.lfeexpstr != EXP_REUSE))
 622     {
 623         p_ac3dec->audblk.lfeexps[0] = GetBits (&p_ac3dec->bit_stream,4);
 624         p_ac3dec->audblk.lfeexps[1] = GetBits (&p_ac3dec->bit_stream,7);
 625         p_ac3dec->total_bits_read += 11;
 626         if (p_ac3dec->audblk.lfeexps[1] >= 125)
 627         {
 628             return 1;
 629         }
 630         p_ac3dec->audblk.lfeexps[2] = GetBits (&p_ac3dec->bit_stream,7);
 631         p_ac3dec->total_bits_read += 7;
 632         if (p_ac3dec->audblk.lfeexps[2] >= 125)
 633         {
 634             return 1;
 635         }
 636     }
 637
 638     /* Get the parametric bit allocation parameters */
 639     p_ac3dec->audblk.baie = GetBits (&p_ac3dec->bit_stream,1);
 640     p_ac3dec->total_bits_read += 1;
 641
 642     if ((!blknum) && (!p_ac3dec->audblk.baie))
 643     {
 644         return 1;
 645     }
 646
 647     if (p_ac3dec->audblk.baie)
 648     {
 649         p_ac3dec->audblk.sdcycod = GetBits (&p_ac3dec->bit_stream,2);
 650         p_ac3dec->audblk.fdcycod = GetBits (&p_ac3dec->bit_stream,2);
 651         p_ac3dec->audblk.sgaincod = GetBits (&p_ac3dec->bit_stream,2);
 652         p_ac3dec->audblk.dbpbcod = GetBits (&p_ac3dec->bit_stream,2);
 653         p_ac3dec->audblk.floorcod = GetBits (&p_ac3dec->bit_stream,3);
 654         p_ac3dec->total_bits_read += 11;
 655     }
 656
 657     /* Get the SNR off set info if it exists */
 658     p_ac3dec->audblk.snroffste = GetBits (&p_ac3dec->bit_stream,1);
 659     if ((!blknum) && (!p_ac3dec->audblk.snroffste))
 660     {
 661         return 1;
 662     }
 663
 664     if (p_ac3dec->audblk.snroffste)
 665     {
 666         p_ac3dec->audblk.csnroffst = GetBits (&p_ac3dec->bit_stream,6);
 667         p_ac3dec->total_bits_read += 6;
 668
 669         if (p_ac3dec->audblk.cplinu)
 670         {
 671             p_ac3dec->audblk.cplfsnroffst = GetBits (&p_ac3dec->bit_stream,4);
 672             p_ac3dec->audblk.cplfgaincod = GetBits (&p_ac3dec->bit_stream,3);
 673             p_ac3dec->total_bits_read += 7;
 674         }
 675
 676         for (i = 0;i < p_ac3dec->bsi.nfchans; i++)
 677         {
 678             p_ac3dec->audblk.fsnroffst[i] = GetBits (&p_ac3dec->bit_stream,4);
 679             p_ac3dec->audblk.fgaincod[i] = GetBits (&p_ac3dec->bit_stream,3);
 680         }
 681         p_ac3dec->total_bits_read += 7 * p_ac3dec->bsi.nfchans;
 682         if (p_ac3dec->bsi.lfeon)
 683         {
 684             p_ac3dec->audblk.lfefsnroffst = GetBits (&p_ac3dec->bit_stream,4);
 685             p_ac3dec->audblk.lfefgaincod = GetBits (&p_ac3dec->bit_stream,3);
 686             p_ac3dec->total_bits_read += 7;
 687         }
 688     }
 689
 690     /* Get coupling leakage info if it exists */
 691     if (p_ac3dec->audblk.cplinu)
 692     {
 693         p_ac3dec->audblk.cplleake = GetBits (&p_ac3dec->bit_stream,1);
 694         p_ac3dec->total_bits_read += 1;
 695         if ((!blknum) && (!p_ac3dec->audblk.cplleake))
 696         {
 697             return 1;
 698         }
 699
 700         if (p_ac3dec->audblk.cplleake)
 701         {
 702             p_ac3dec->audblk.cplfleak = GetBits (&p_ac3dec->bit_stream,3);
 703             p_ac3dec->audblk.cplsleak = GetBits (&p_ac3dec->bit_stream,3);
 704             p_ac3dec->total_bits_read += 6;
 705         }
 706     }
 707
 708     /* Get the delta bit alloaction info */
 709     p_ac3dec->audblk.deltbaie = GetBits (&p_ac3dec->bit_stream,1);
 710     p_ac3dec->total_bits_read += 1;
 711
 712     if (p_ac3dec->audblk.deltbaie)
 713     {
 714         if (p_ac3dec->audblk.cplinu)
 715         {
 716             p_ac3dec->audblk.cpldeltbae = GetBits (&p_ac3dec->bit_stream,2);
 717             p_ac3dec->total_bits_read += 2;
 718             if (p_ac3dec->audblk.cpldeltbae == 3)
 719             {
 720                 return 1;
 721             }
 722         }
 723
 724         for (i = 0;i < p_ac3dec->bsi.nfchans; i++)
 725         {
 726             p_ac3dec->audblk.deltbae[i] = GetBits (&p_ac3dec->bit_stream,2);
 727             p_ac3dec->total_bits_read += 2;
 728             if (p_ac3dec->audblk.deltbae[i] == 3)
 729             {
 730                 return 1;
 731             }
 732         }
 733
 734         if (p_ac3dec->audblk.cplinu && (p_ac3dec->audblk.cpldeltbae == DELTA_BIT_NEW))
 735         {
 736             p_ac3dec->audblk.cpldeltnseg = GetBits (&p_ac3dec->bit_stream,3);
 737             for (i = 0;i < p_ac3dec->audblk.cpldeltnseg + 1; i++)
 738             {
 739                 p_ac3dec->audblk.cpldeltoffst[i] = GetBits (&p_ac3dec->bit_stream,5);
 740                 p_ac3dec->audblk.cpldeltlen[i] = GetBits (&p_ac3dec->bit_stream,4);
 741                 p_ac3dec->audblk.cpldeltba[i] = GetBits (&p_ac3dec->bit_stream,3);
 742             }
 743             p_ac3dec->total_bits_read += 12 * (p_ac3dec->audblk.cpldeltnseg + 1) + 3;
 744         }
 745
 746         for (i = 0; i < p_ac3dec->bsi.nfchans; i++)
 747         {
 748             if (p_ac3dec->audblk.deltbae[i] == DELTA_BIT_NEW)
 749             {
 750                 p_ac3dec->audblk.deltnseg[i] = GetBits (&p_ac3dec->bit_stream,3);
 751 //                if (p_ac3dec->audblk.deltnseg[i] >= 8)
 752 //                    fprintf (stderr, "parse debug: p_ac3dec->audblk.deltnseg[%i] == %i\n", i, p_ac3dec->audblk.deltnseg[i]);
 753                 for (j = 0; j < p_ac3dec->audblk.deltnseg[i] + 1; j++)
 754                 {
 755                     p_ac3dec->audblk.deltoffst[i][j] = GetBits (&p_ac3dec->bit_stream,5);
 756                     p_ac3dec->audblk.deltlen[i][j] = GetBits (&p_ac3dec->bit_stream,4);
 757                     p_ac3dec->audblk.deltba[i][j] = GetBits (&p_ac3dec->bit_stream,3);
 758                 }
 759                 p_ac3dec->total_bits_read += 12 * (p_ac3dec->audblk.deltnseg[i] + 1) + 3;
 760             }
 761         }
 762     }
 763
 764     /* Check to see if there's any dummy info to get */
 765     p_ac3dec->audblk.skiple = GetBits (&p_ac3dec->bit_stream,1);
 766     p_ac3dec->total_bits_read += 1;
 767
 768     if (p_ac3dec->audblk.skiple)
 769     {
 770         p_ac3dec->audblk.skipl = GetBits (&p_ac3dec->bit_stream,9);
 771
 772         for (i = 0; i < p_ac3dec->audblk.skipl ; i++)
 773         {
 774             GetBits (&p_ac3dec->bit_stream,8);
 775         }
 776         p_ac3dec->total_bits_read += 8 * p_ac3dec->audblk.skipl + 9;
 777     }
 778
 779     if( p_main->b_stats )
 780     {
 781         parse_audblk_stats(p_ac3dec);
 782     }
 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 static void parse_bsi_stats (ac3dec_t * p_ac3dec) /* Some stats */
 810 {
 811 #if 0
 812     struct mixlev_s
 813     {
 814         float clev;
 815         char *desc;
 816     };
 817     static const char *service_ids[8] =
 818     {
 819         "CM","ME","VI","HI",
 820         "D", "C","E", "VO"
 821     };
 822 /*
 823     static const struct mixlev_s cmixlev_tbl[4] =
 824     {
 825         {0.707, "(-3.0 dB)"}, {0.595, "(-4.5 dB)"},
 826         {0.500, "(-6.0 dB)"}, {1.0,  "Invalid"}
 827     };
 828     static const struct mixlev_s smixlev_tbl[4] =
 829     {
 830         {0.707, "(-3.0 dB)"}, {0.500, "(-6.0 dB)"},
 831         {  0.0,   "off    "}, {  1.0, "Invalid"}
 832     };
 833  */
 834
 835     static int  i=0;
 836
 837     if ( !i )
 838     {
 839 /*      if ((p_ac3dec->bsi.acmod & 0x1) && (p_ac3dec->bsi.acmod != 0x1))
 840                printf("CentreMixLevel %s ",cmixlev_tbl[p_ac3dec->bsi.cmixlev].desc);
 841         if (p_ac3dec->bsi.acmod & 0x4)
 842                printf("SurMixLevel %s",smixlev_tbl[p_ac3dec->bsi.cmixlev].desc);
 843  */
 844         intf_Msg ( "(ac3dec_parsebsi) %s %d.%d Mode",
 845                 service_ids[p_ac3dec->bsi.bsmod],
 846                 p_ac3dec->bsi.nfchans,p_ac3dec->bsi.lfeon);
 847     }
 848     i++;
 849
 850     if ( i > 100 )
 851         i = 0;
 852 #endif
 853 }
 854
 855 static void parse_audblk_stats (ac3dec_t * p_ac3dec)
 856 {
 857 #if 0
 858     char *exp_strat_tbl[4] = {"R   ","D15 ","D25 ","D45 "};
 859     u32 i;
 860     intf_ErrMsg ("(ac3dec_parseaudblk) ");
 861     intf_ErrMsg ("%s ",p_ac3dec->audblk.cplinu ? "cpl on" : "cpl off");
 862     intf_ErrMsg ("%s ",p_ac3dec->audblk.baie? "bai" : " ");
 863     intf_ErrMsg ("%s ",p_ac3dec->audblk.snroffste? "snroffst" : " ");
 864     intf_ErrMsg ("%s ",p_ac3dec->audblk.deltbaie? "deltba" : " ");
 865     intf_ErrMsg ("%s ",p_ac3dec->audblk.phsflginu? "phsflg" : " ");
 866     intf_ErrMsg ("(%s %s %s %s %s) ",exp_strat_tbl[p_ac3dec->audblk.chexpstr[0]],
 867            exp_strat_tbl[p_ac3dec->audblk.chexpstr[1]],exp_strat_tbl[p_ac3dec->audblk.chexpstr[2]],
 868            exp_strat_tbl[p_ac3dec->audblk.chexpstr[3]],exp_strat_tbl[p_ac3dec->audblk.chexpstr[4]]);
 869     intf_ErrMsg ("[");
 870     for(i=0;i<p_ac3dec->bsi.nfchans;i++)
 871             intf_ErrMsg ("%1d",p_ac3dec->audblk.blksw[i]);
 872     intf_ErrMsg ("]");
 873 #endif
 874 }
 875