git.sesse.net Git - vlc/blob - src/ac3_decoder/ac3_parse.c

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