ADX (file format)

 #define M_PI acos(-1.0)
 double a, b, c;
 a = sqrt(2.0) - cos(2.0 * M_PI * ((double)adx_header->highpass_frequency / adx_header->sample_rate));
 b = sqrt(2.0) - 1.0;
 c = (a - sqrt((a + b) * (a - b))) / b; //(a+b)*(a-b) = a*a-b*b, however the simpler formula loses accuracy in floating point
 
 // double coefficient[2];
 coefficient[0] = c * 2.0;
 coefficient[1] = -(c * c);

 static int32_t*      past_samples; // Previously decoded samples from each channel, zeroed at start (size = 2*channel_count)
 static uint_fast32_t sample_index = 0; // sample_index is the index of sample set that needs to be decoded next
 static ADX_header*   adx_header;
 
 // buffer is where the decoded samples will be put
 // samples_needed states how many sample 'sets' (one sample from every channel) need to be decoded to fill the buffer
 // looping_enabled is a boolean flag to control use of the built-in loop
 // Returns the number of sample 'sets' in the buffer that could not be filled (EOS)
 unsigned decode_adx_standard( int16_t* buffer, unsigned samples_needed, bool looping_enabled )
 {
  unsigned const samples_per_block = (adx_header->block_size - 2) * 8 / adx_header->sample_bitdepth;
  int16_t scale[ adx_header->channel_count ];
 
  if (looping_enabled && !adx_header->loop_enabled)
     looping_enabled = false;
 
  // Loop until the requested number of samples are decoded, or the end of file is reached
  while (samples_needed > 0 && sample_index < adx_header->total_samples)
  {
     // Calculate the number of samples that are left to be decoded in the current block
     unsigned sample_offset = sample_index % samples_per_block;
     unsigned samples_can_get = samples_per_block - sample_offset;

     // Clamp the samples we can get during this run if they won't fit in the buffer
     if (samples_can_get > samples_needed)
        samples_can_get = samples_needed;
 
     // Clamp the number of samples to be acquired if the stream isn't long enough or the loop trigger is nearby
     if (looping_enabled && sample_index + samples_can_get > adx_header->loop_end_index)
        samples_can_get = adx_header->loop_end_index - sample_index;
     else if (sample_index + samples_can_get > adx_header->total_samples)
        samples_can_get = adx_header->total_samples - sample_index;
 
     // Calculate the bit address of the start of the frame that sample_index resides in and record that location
     unsigned long started_at = (adx_header->copyright_offset + 4 + \
                     sample_index / samples_per_block * adx_header->block_size * adx_header->channel_count) * 8;
 
     // Read the scale values from the start of each block in this frame
     for (unsigned i = 0 ; i < adx_header->channel_count ; ++i)
     {
        bitstream_seek( started_at + adx_header->block_size * i * 8 );
        scale[i] = ntohs( bitstream_read( 16 ) );
     }
 
     // Pre-calculate the stop value for sample_offset
     unsigned sample_endoffset = sample_offset + samples_can_get;
 
     // Save the bitstream address of the first sample immediately after the scale in the first block of the frame
     started_at += 16;
     while ( sample_offset < sample_endoffset )
     {
        for (unsigned i = 0 ; i < adx_header->channel_count ; ++i)
        {
           // Predict the next sample
           double sample_prediction = coefficient[0] * past_samples[i*2 + 0] + coefficient[1] * past_samples[i*2 + 1];
 
           // Seek to the sample offset, read and sign extend it to a 32bit integer
           // Implementing sign extension is left as an exercise for the reader
           // The sign extension will also need to include a endian adjustment if there are more than 8 bits
           bitstream_seek( started_at + adx_header->sample_bitdepth * sample_offset + \
                           adx_header->block_size * 8 * i );
           int_fast32_t sample_error = bitstream_read( adx_header->sample_bitdepth );
           sample_error = sign_extend( sample_error, adx_header->sample_bitdepth );
 
           // Scale the error correction value
           sample_error *= scale[i];
 
           // Calculate the sample by combining the prediction with the error correction
           int_fast32_t sample = sample_error + (int_fast32_t)sample_prediction;
 
           // Update the past samples with the newer sample
           past_samples[i*2 + 1] = past_samples[i*2 + 0];
           past_samples[i*2 + 0] = sample;
 
           // Clamp the decoded sample to the valid range for a 16bit integer
           if (sample > 32767)
              sample = 32767;
           else if (sample < -32768)
              sample = -32768;
 
           // Save the sample to the buffer then advance one place
           *buffer++ = sample;
        }
        ++sample_offset;  // We've decoded one sample from every block, advance block offset by 1
        ++sample_index;   // This also means we're one sample further into the stream
        --samples_needed; // And so there is one less set of samples that need to be decoded
    }
 
    // Check if we hit the loop end marker, if we did we need to jump to the loop start
    if (looping_enabled && sample_index == adx_header->loop_end_index)
       sample_index = adx_header->loop_start_index;
  }
 
  return samples_needed;
 }