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