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