From 9a858f636bbd3e2d0e6a9a6ff48cfe7df32b8d65 Mon Sep 17 00:00:00 2001
From: James Courtier-Dutton <jcdutton@users.sourceforge.net>
Date: Sun, 25 May 2003 15:23:51 +0000
Subject: Some more parsing code.

CVS patchset: 4928
CVS date: 2003/05/25 15:23:51
---
 src/libdts/xine_decoder.c | 418 +++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 415 insertions(+), 3 deletions(-)

(limited to 'src')

diff --git a/src/libdts/xine_decoder.c b/src/libdts/xine_decoder.c
index 833e8be81..f1f1ed393 100644
--- a/src/libdts/xine_decoder.c
+++ b/src/libdts/xine_decoder.c
@@ -17,7 +17,7 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA
  *
- * $Id: xine_decoder.c,v 1.40 2003/05/24 13:21:24 jcdutton Exp $
+ * $Id: xine_decoder.c,v 1.41 2003/05/25 15:23:51 jcdutton Exp $
  *
  * 04-09-2001 DTS passtrough  (C) Joachim Koenig 
  * 09-12-2001 DTS passthrough inprovements (C) James Courtier-Dutton
@@ -282,32 +282,60 @@ static void dts_parse_data (dts_decoder_t *this, buf_element_t *buf) {
   printf("\n");
 
   getbits_init(&state, &data_in[4]);
+
+  /* B.2 Unpack Frame Header Routine */
+  /* Frame Type V FTYPE 1 bit */
   frame_type = getbits(&state, 1); /* 1: Normal Frame, 2:Termination Frame */
+  /* Deficit Sample Count V SHORT 5 bits */
   deficit_sample_count = getbits(&state, 5);
+  /* CRC Present Flag V CPF 1 bit */
   crc_present_flag = getbits(&state, 1);
+  /* Number of PCM Sample Blocks V NBLKS 7 bits */
   number_of_pcm_blocks = getbits(&state, 7);
+  /* Primary Frame Byte Size V FSIZE 14 bits */
   primary_frame_byte_size = getbits(&state, 14);
+  /* Audio Channel Arrangement ACC AMODE 6 bits */
   audio_channel_arrangement = getbits(&state, 6);
+  /* Core Audio Sampling Frequency ACC SFREQ 4 bits */
   core_audio_sampling_frequency = getbits(&state, 4);
+  /* Transmission Bit Rate ACC RATE 5 bits */
   transmission_bit_rate = getbits(&state, 5);
+  /* Embedded Down Mix Enabled V MIX 1 bit */
   embedded_down_mix_enabled = getbits(&state, 1);
+  /* Embedded Dynamic Range Flag V DYNF 1 bit */
   embedded_dynamic_range_flag = getbits(&state, 1);
+  /* Embedded Time Stamp Flag V TIMEF 1 bit */
   embedded_time_stamp_flag = getbits(&state, 1);
+  /* Auxiliary Data Flag V AUXF 1 bit */
   auxiliary_data_flag = getbits(&state, 1);
+  /* HDCD NV HDCD 1 bits */
   hdcd = getbits(&state, 1);
+  /* Extension Audio Descriptor Flag ACC EXT_AUDIO_ID 3 bits */
   extension_audio_descriptor_flag = getbits(&state, 3);
+  /* Extended Coding Flag ACC EXT_AUDIO 1 bit */
   extended_coding_flag = getbits(&state, 1);
+  /* Audio Sync Word Insertion Flag ACC ASPF 1 bit */
   audio_sync_word_insertion_flag = getbits(&state, 1);
+  /* Low Frequency Effects Flag V LFF 2 bits */
   low_frequency_effects_flag = getbits(&state, 2);
+  /* Predictor History Flag Switch V HFLAG 1 bit */
   predictor_history_flag_switch = getbits(&state, 1);
+  /* Header CRC Check Bytes V HCRC 16 bits */
   if (crc_present_flag == 1) 
     header_crc_check_bytes  = getbits(&state, 16);
+  /* Multirate Interpolator Switch NV FILTS 1 bit */
   multirate_interpolator_switch = getbits(&state, 1);
+  /* Encoder Software Revision ACC/NV VERNUM 4 bits */
   encoder_software_revision = getbits(&state, 4);
+  /* Copy History NV CHIST 2 bits */
   copy_history = getbits(&state, 2);
+  /* Source PCM Resolution ACC/NV PCMR 3 bits */
   source_pcm_resolution = getbits(&state, 3);
+  /* Front Sum/Difference Flag V SUMF 1 bit */
   front_sum_difference_flag = getbits(&state, 1);
+  /* Surrounds Sum/Difference Flag V SUMS 1 bit */
   surrounds_sum_difference_flag = getbits(&state, 1);
+  /* Dialog Normalisation Parameter/Unspecified V DIALNORM/UNSPEC 4 bits */
   switch (encoder_software_revision) {
   case 6:
     dialog_normalisation_unspecified = 0;
@@ -325,28 +353,38 @@ static void dts_parse_data (dts_decoder_t *this, buf_element_t *buf) {
     break;
   }
 
+  /* B.3 Audio Decoding */
+  /* B.3.1 Primary Audio Coding Header */
 
+  /* Number of Subframes V SUBFS 4 bits */
   number_of_subframes = getbits(&state, 4) + 1 ;
+  /* Number of Primary Audio Channels V PCHS 3 bits */
   number_of_primary_audio_channels = getbits(&state, 3) + 1 ;
+  /* Subband Activity Count V SUBS 5 bits per channel */
   for (ch=0; ch<number_of_primary_audio_channels; ch++) {
     subband_activity_count[ch] = getbits(&state, 5) + 2 ;
   }
+  /* High Frequency VQ Start Subband V VQSUB 5 bits per channel */
   for (ch=0; ch<number_of_primary_audio_channels; ch++) {
     high_frequency_VQ_start_subband[ch] = getbits(&state, 5) + 1 ;
   }
+  /* Joint Intensity Coding Index V JOINX 3 bits per channel */
   for (n=0; ch<number_of_primary_audio_channels; ch++) {
     joint_intensity_coding_index[ch] = getbits(&state, 3) ;
   }
+  /* Transient Mode Code Book V THUFF 2 bits per channel */
   for (ch=0; ch<number_of_primary_audio_channels; ch++) {
     transient_mode_code_book[ch] = getbits(&state, 2) ;
   }
+  /* Scale Factor Code Book V SHUFF 3 bits per channel */
   for (ch=0; ch<number_of_primary_audio_channels; ch++) {
     scales_factor_code_book[ch] = getbits(&state, 3) ;
   }
+  /* Bit Allocation Quantizer Select BHUFF V 3 bits per channel */
   for (ch=0; ch<number_of_primary_audio_channels; ch++) {
     bit_allocation_quantizer_select[ch] = getbits(&state, 3) ;
   }
-
+  /* Quantization Index Codebook Select V SEL variable bits */
   /* ABITS=1: */
   n=0;
   for (ch=0; ch<number_of_primary_audio_channels; ch++)
@@ -363,7 +401,7 @@ static void dts_parse_data (dts_decoder_t *this, buf_element_t *buf) {
   for (n=10; n<26; n++)
     for (ch=0; ch<number_of_primary_audio_channels; ch++)
       quantization_index_codebook_select[ch][n] = 0; /* Not transmitted, set to zero. */
-
+  /* Scale Factor Adjustment Index V ADJ 2 bits per occasion */
   /* ABITS = 1: */
   n = 0;
   for (ch=0; ch<number_of_primary_audio_channels; ch++) {
@@ -404,6 +442,380 @@ static void dts_parse_data (dts_decoder_t *this, buf_element_t *buf) {
     audio_header_crc_check_word = getbits(&state, 16);
   }
 
+#if 0
+
+/* FIXME: ALL CODE BELOW HERE does not compile yet. */
+
+/* B.3.2          Unpack Subframes */
+/* B.3.2.1 Primary Audio Coding Side Information */
+
+/* Subsubframe Count V SSC 2 bit */
+  subsubframe_count = getbits(&state, 2) + 1;
+/* Partial Subsubframe Sample Count V PSC 3 bit */
+  partial_subsubframe_sample_count = getbits(&state, 3);
+/* Prediction Mode V PMODE 1 bit per subband */
+  for (ch=0; ch<number_of_primary_audio_channels; ch++)
+    for (n=0; n<subband_activity_count[ch]; n++)
+      prediction_mode[ch][n] = getbits(&state, 1);
+
+/* Prediction Coefficients VQ Address V PVQ 12 bits per occurrence */
+  int32_t nVQIndex;
+  for (ch=0; ch<number_of_primary_audio_channels; ch++) {
+    for (n=0; n<subband_activity_count[ch]; n++) {
+      if ( prediction_mode[ch][n]>0 ) { /* Transmitted only when ADPCM active */
+        /* Extract the VQindex */
+        nVQIndex = getbits(&state,12);
+        /* Look up the VQ table for prediction coefficients. */
+        /* FIXME: How to implement LookUp? */
+        ADPCMCoeffVQ.LookUp(nVQIndex, PVQ[ch][n]); /*  4 coefficients  FIXME: Need to work out what this does. */
+      }
+    }
+  }
+
+
+  /* Bit Allocation Index V ABITS variable bits */
+  /* FIXME: No getbits here */
+  /* FIXME: What is InverseQ? */
+  int32_t nQSelect;
+  for (ch=0; ch<number_of_primary_audio_channels; ch++) {
+    /* Bit Allocation Quantizer Select tells which codebook was used */
+    nQSelect = bit_allocation_quantizer_select[ch]; 
+    /* Use this codebook to decode the bit stream for bit_allocation_index[ch][n] */
+    for (n=0; n<high_frequency_VQ_start_subband[ch]; n++) {
+      /* Not for VQ encoded subbands. */
+      /* QABITS.ppQ[nQSelect]->InverseQ(InputFrame, bit_allocation_index[ch][n]); */
+    }
+  }
+
+  /* Transition Mode V TMODE variable bits */
+
+  /* Always assume no transition unless told */
+  int32_t nQSelect;
+  for (ch=0; ch<number_of_primary_audio_channels; ch++){
+    for (n=0; n<subband_activity_count[ch]; n++) {
+      transition_mode[ch][n] = 0;
+    } 
+    /* Decode transition_mode[ch][n] */
+    if ( subsubframe_count>1 ) {
+      /* Transient possible only if more than one subsubframe. */
+      for (ch=0; ch<number_of_primary_audio_channels; ch++) {
+        /* transition_mode[ch][n] is encoded by a codebook indexed by transient_mode_code_book[ch] */
+        nQSelect = transient_mode_code_book[ch];
+        for (n=0; n<high_frequency_VQ_start_subband[ch]; n++) {
+          /* No VQ encoded subbands */
+          if ( bit_allocation_index[ch][n] >0 ) {
+            /* Present only if bits allocated */
+            /* Use codebook nQSelect to decode transition_mode from the bit stream */
+            QTMODE.ppQ[nQSelect]->InverseQ(InputFrame,transition_mode[ch][n]);
+          }
+        }
+      }
+    }
+  }
+
+  /* Scale Factors V SCALES variable bits */
+  for (ch=0; ch<number_of_primary_audio_channels; ch++) {
+    /* Clear scale_factors */
+    for (n=0; n<subband_activity_count[ch]; n++) {
+      scale_factors[ch][n][0] = 0;
+      scale_factors[ch][n][1] = 0;
+    }
+    /* scales_factor_code_book indicates which codebook was used to encode scale_factors */
+    nQSelect = scales_factor_code_book[ch];
+    /* Select the root square table (scale_factors were nonlinearly */
+    /* quantized). */
+    if ( nQSelect == 6 ) {
+      pScaleTable = &RMS7Bit; /* 7-bit root square table */
+    } else {
+      pScaleTable = &RMS6Bit; /* 6-bit root square table */
+    }
+    /*
+     * Clear accumulation (if Huffman code was used, the difference
+     * of scale_factors was encoded).
+     */
+    nScaleSum = 0;
+    /*
+     * Extract scale_factors for Subbands up to high_frequency_VQ_start_subband[ch]
+     */
+    for (n=0; n<high_frequency_VQ_start_subband[ch]; n++) {
+      if ( bit_allocation_index[ch][n] >0 ) { /* Not present if no bit allocated */
+        /*
+         * First scale factor
+         */
+        /* Use the (Huffman) code indicated by nQSelect to decode */
+        /* the quantization index of scale_factors from the bit stream */
+        /* FIXME: What is InverseQ ??? */
+        QSCALES.ppQ[nQSelect]->InverseQ(InputFrame, nScale);
+        /* Take care of difference encoding */
+        if ( nQSelect < 5 ) { /* Huffman encoded, nScale is the difference */
+          nScaleSum += nScale; /* of the quantization indexes of scale_factors. */
+        } else { /* Otherwise, nScale is the quantization */
+          nScaleSum = nScale; /* level of scale_factors. */
+        }
+        /* Look up scale_factors from the root square table */
+        /* FIXME: How to implement LookUp? */
+        pScaleTable->LookUp(nScaleSum, scale_factors[ch][n][0])
+        /*
+         * Two scale factors transmitted if there is a transient
+         */
+        if (transition_mode[ch][n]>0) {
+          /* Use the (Huffman) code indicated by nQSelect to decode */
+          /* the quantization index of scale_factors from the bit stream */
+          QSCALES.ppQ[nQSelect]->InverseQ(InputFrame, nScale);
+          /* Take care of difference encoding */
+          if ( nQSelect < 5 ) /* Huffman encoded, nScale is the difference */
+            nScaleSum += nScale; /* of the quantization indexes of scale_factors. */
+          else /* Otherwise, nScale is the quantization */
+            nScaleSum = nScale; /* level of scale_factors. */
+          /* Look up scale_factors from the root square table */
+          /* FIXME: How to implement LookUp? */
+          pScaleTable->LookUp(nScaleSum, scale_factors[ch][n][1]);
+        }
+      }
+    }
+    /*
+     * High frequency VQ subbands
+     */
+    for (n=high_frequency_VQ_start_subband[ch]; n<subband_activity_count[ch]; n++) {
+      /* Use the code book indicated by nQSelect to decode */
+      /* the quantization index of scale_factors from the bit stream */
+      QSCALES.ppQ[nQSelect]->InverseQ(InputFrame, nScale);
+      /* Take care of difference encoding */
+      if ( nQSelect < 5 ) /* Huffman encoded, nScale is the difference */
+        nScaleSum += nScale; /* of the quantization indexes of scale_factors. */
+      else /* Otherwise, nScale is the quantization */
+        nScaleSum = nScale; /* level of scale_factors. */
+      /* Look up scale_factors from the root square table */
+      /* FIXME: How to implement LookUp? */
+      pScaleTable->LookUp(nScaleSum, scale_factors[ch][n][0])
+    }
+  }
+
+
+
+  /* Joint Subband Scale Factor Codebook Select V JOIN SHUFF 3 bits per channel */
+  for (ch=0; ch<number_of_primary_audio_channels; ch++)
+    if (joint_intensity_coding_index[ch]>0 ) /* Transmitted only if joint subband coding enabled. */
+      joint_subband_scale_factor_codebook_select[ch] = getbits(&state,3);
+
+  /* Scale Factors for Joint Subband Coding V JOIN SCALES variable bits */
+  int nSourceCh;
+  for (ch=0; ch<number_of_primary_audio_channels; ch++) {
+    if (joint_intensity_coding_index[ch]>0 ) { /* Only if joint subband coding enabled. */
+      nSourceCh = joint_intensity_coding_index[ch]-1; /* Get source channel. joint_intensity_coding_index counts */
+      /* channels as 1,2,3,4,5, so minus 1. */
+      nQSelect = joint_subband_scale_factor_codebook_select[ch]; /* Select code book. */
+      for (n=subband_activity_count[ch]; n<subband_activity_count[nSourceCh]; n++) {
+        /* Use the code book indicated by nQSelect to decode */
+        /* the quantization index of scale_factors_for_joint_subband_coding */
+        QSCALES.ppQ[nQSelect]->InverseQ(InputFrame, nJScale);
+        /* Bias by 64 */
+        nJScale = nJScale + 64;
+        /* Look up scale_factors_for_joint_subband_coding from the joint scale table */
+        /* FIXME: How to implement LookUp? */
+        JScaleTbl.LookUp(nJScale, scale_factors_for_joint_subband_coding[ch][n]);
+      }
+    }
+  }
+
+  /* Stereo Down-Mix Coefficients NV DOWN 7 bits per coefficient */
+  if ( (MIX!=0) && (number_of_primary_audio_channels>2) ) {
+    /* Extract down mix indexes */
+    for (ch=0; ch<number_of_primary_audio_channels; ch++) { /* Each primary channel */
+      stereo_down_mix_coefficients[ch][0] = getbits(&state,7);
+      stereo_down_mix_coefficients[ch][1] = getbits(&state,7);
+    }
+  }
+  /* Look up down mix coefficients */
+  for (n=0; n<subband_activity_count; n++) { /* Each active subbands */
+    LeftChannel = 0;
+    RightChannel = 0;
+    for (ch=0; ch<number_of_primary_audio_channels; ch++) { /* Each primary channels */
+      LeftChannel += stereo_down_mix_coefficients[ch][0]*Sample[Ch];
+      RightChannel += stereo_down_mix_coefficients[ch][1]*Sample[Ch];
+    }
+  }
+  /* Down mixing may also be performed on the PCM samples after the filterbank reconstruction. */
+
+  /* Dynamic Range Coefficient NV RANGE 8 bits */
+  if ( embedded_dynamic_range_flag != 0 ) {
+    nIndex = getbits(&state,8);
+    /* FIXME: How to implement LookUp? */
+    RANGEtbl.LookUp(nIndex,dynamic_range_coefficient);
+    /* The following range adjustment is to be performed */
+    /* after QMF reconstruction */
+    for (ch=0; ch<number_of_primary_audio_channels; ch++)
+      for (n=0; n<nNumSamples; n++)
+        AudioCh[ch].ReconstructedSamples[n] *= dynamic_range_coefficient;
+  }
+
+  /* Side Information CRC Check Word V SICRC 16 bits */
+  if ( CPF==1 ) /* Present only if CPF=1. */
+    SICRC = getbits(&state,16);
+
+  /* B.3.3 Primary Audio Data Arrays */
+
+  /* VQ Encoded High Frequency Subbands NV HFREQ 10 bits per applicable subbands */
+  for (ch=0; ch<number_of_primary_audio_channels; ch++) {
+    for (n=high_frequency_VQ_start_subband[ch]; n<subband_activity_count[ch]; n++) {
+      /* Extract the VQ address from the bit stream */
+      nVQIndex = getbits(&state,10);
+      /* Look up the VQ code book for 32 subband samples. */
+      /* FIXME: How to implement LookUp? */
+      HFreqVQ.LookUp(nVQIndex, VQ_encoded_high_frequency_subbands[ch][n])
+      /* Scale and take the samples */
+      Scale = (real)scale_factors[ch][n][0]; /* Get the scale factor */
+      for (m=0; m<subsubframe_count*8; m++, nSample++) {
+        aPrmCh[ch].aSubband[n].raSample[m] = rScale*VQ_encoded_high_frequency_subbands[ch][n][m];
+      }
+    }
+  }
+
+  /* Low Frequency Effect Data V LFE 8 bits per sample */
+  if ( low_frequency_effects_flag>0 ) { /* Present only if flagged by low_frequency_effects_flag */
+    /* extract low_frequency_effect_data samples from the bit stream */
+    for (n=0; n<2*low_frequency_effects_flag*subsubframe_count; n++) {
+      low_frequency_effect_data[n] = (signed int)(signed char)getbits(&state,8);
+      /* Use char to get sign extension because it */
+      /* is 8-bit 2's compliment. */
+      /* Extract scale factor index from the bit stream */
+    }
+    LFEscaleIndex = getbits(&state,8);
+    /* Look up the 7-bit root square quantization table */
+    /* FIXME: How to implement LookUp? */
+    pLFE_RMS->LookUp(LFEscaleIndex,nScale);
+    /* Account for the quantizer step size which is 0.035 */
+    rScale = nScale*0.035;
+    /* Get the actual low_frequency_effect_data samples */
+    for (n=0; n<2*low_frequency_effects_flag*subsubframe_count; n++) {
+      LFECh.rLFE[k] = low_frequency_effect_data[n]*rScale;
+    }
+    /* Interpolation low_frequency_effect_data samples */
+    LFECh.InterpolationFIR(low_frequency_effects_flag); /* low_frequency_effects_flag indicates which */
+    /* interpolation filter to use */
+  }
+
+  /* Audio Data V AUDIO variable bits */
+  /*
+   * Select quantization step size table
+   */
+  if ( RATE == 0x1f ) {
+    pStepSizeTable = &StepSizeLossLess; /* Lossless quantization */
+  } else {
+    pStepSizeTable = &StepSizeLossy; /* Lossy */
+  }
+  /*
+   * Unpack the subband samples
+   */
+  for (nSubSubFrame=0; nSubSubFrame<subsubframe_count; nSubSubFrame++) {
+    for (ch=0; ch<number_of_primary_audio_channels; ch++) {
+      for (n=0; n<high_frequency_VQ_start_subband[ch]; n++) { /* Not high frequency VQ subbands */
+      /*
+       * Select the mid-tread linear quantizer
+       */
+      nABITS = bit_allocation_index[ch][n]; /* Select the mid-tread quantizer */
+      pCQGroup = &pCQGroupAUDIO[nABITS-1];/* Select the group of */
+      /* code books corresponding to the */
+      /* the mid-tread linear quantizer. */
+      nNumQ = pCQGroupAUDIO[nABITS-1].nNumQ-1;/* Number of code */
+      /* books in this group */
+      /*
+       * Determine quantization index code book and its type
+       */
+      /* Select quantization index code book */
+      nSEL = SEL[ch][nABITS-1];
+      /* Determine its type */
+      nQType = 1; /* Assume Huffman type by default */
+      if ( nSEL==nNumQ ) { /* Not Huffman type */
+        if ( nABITS<=7 ) {
+          nQType = 3; /* Block code */
+        } else {
+          nQType = 2; /* No further encoding */
+        }
+      }
+      if ( nABITS==0 ) { /* No bits allocated */
+        nQType = 0;
+      }
+      /*
+       * Extract bits from the bit stream
+       */
+      switch ( nQType ) {
+        case 0: /* No bits allocated */
+          for (m=0; m<8; m++)
+            AUDIO[m] = 0;
+          break;
+        case 1: /* Huffman code */
+          for (m=0; m<8; m++)
+            pCQGroup->ppQ[nSEL]->InverseQ(InputFrame,AUDIO[m]);
+          break;
+        case 2: /* No further encoding */
+          for (m=0; m<8; m++) {
+            /* Extract quantization index from the bit stream */
+            pCQGroup->ppQ[nSEL]->InverseQ(InputFrame, nCode)
+            /* Take care of 2's compliment */
+            AUDIO[m] = pCQGroup->ppQ[nSEL]->SignExtension(nCode);
+          }
+          break;
+        case 3: /* Block code */
+          pCBQ = &pCBlockQ[nABITS-1]; /* Select block code book */
+          m = 0;
+          for (nBlock=0; nBlock<2; nBlock++) {
+            /* Extract the block code index from the bit stream */
+            pCQGroup->ppQ[nSEL]->InverseQ(InputFrame, nCode)
+            /* Look up 4 samples from the block code book */
+            /* FIXME: How to implement LookUp? */
+            pCBQ->LookUp(nCode,&AUDIO[m])
+            m += 4;
+          }
+          break;
+        default: /* Undefined */
+          printf("ERROR: Unknown AUDIO quantization index code book.");
+      }
+      /*
+       * Account for quantization step size and scale factor
+       */
+      /* Look up quantization step size */
+      nABITS = bit_allocation_index[ch][n];
+      /* FIXME: How to implement LookUp? */
+      pStepSizeTable->LookUp(nABITS, rStepSize);
+      /* Identify transient location */
+      nTmode = transition_mode[ch][n];
+      if ( nTmode == 0 ) /* No transient */
+        nTmode = subsubframe_count;
+      /* Determine proper scale factor */
+      if (nSubSubFrame<nTmode) /* Pre-transient */
+        rScale = rStepSize * scale_factors[ch][n][0]; /* Use first scale factor */
+      else /* After-transient */
+        rScale = rStepSize * scale_factors[ch][n][1]; /* Use second scale factor */
+      /* Adjustmemt of scale factor */
+      rScale *= arADJ[ch][SEL[ch][nABITS-1]]; /* arADJ[ ][ ] are assumed 1 */
+      /* unless changed by bit */
+      /* stream when SEL indicates */
+      /* Huffman code. */
+      /* Scale the samples */
+      nSample = 8*nSubSubFrame; /* Set sample index */
+      for (m=0; m<8; m++, nSample++)
+        aPrmCh[ch].aSubband[n].aSample[nSample] = rScale*AUDIO[m];
+      /*
+       * Inverse ADPCM
+       */
+      if ( PMODE[ch][n] != 0 ) /* Only when prediction mode is on. */
+        aPrmCh[ch].aSubband[n].InverseADPCM();
+      /*
+       * Check for DSYNC
+       */
+      if ( (nSubSubFrame==(subsubframe_count-1)) || (ASPF==1) ) {
+        DSYNC = getbits(&state,16);
+        if ( DSYNC != 0xffff )
+          printf("DSYNC error at end of subsubframe #%d", nSubSubFrame);
+      }
+    }
+  }
+/* B.3.4 Unpack Optional Information */
+/* TODO ^^^ */
+
+#endif
+/* CODE BELOW here does compile */
 
   printf("getbits status: byte_pos = %d, bit_pos = %d\n", 
           state.byte_position,
-- 
cgit v1.2.3