CodecDSF.h

Go to the documentation of this file.

 
#pragma once
// #pragma GCC optimize("Ofast")
#pragma GCC optimize("O3")
 
#include "AudioTools/AudioCodecs/AudioCodecsBase.h"
#include "AudioTools/CoreAudio/AudioFilter/Filter.h"
#include "AudioTools/CoreAudio/Buffers.h"
 
#define DSD_BUFFER_SIZE 1024 * 2
 
namespace audio_tools {
 
struct DSFMetadata : public AudioInfo {
  DSFMetadata() = default;
  DSFMetadata(int rate) { sample_rate = rate; }
  uint32_t dsd_sample_rate =
      0;                        
  uint64_t dsd_data_bytes = 0;  
  uint8_t dsd_bits = 1;         
  uint64_t pcm_frames = 0;  
  float duration_sec = 0;   
  uint32_t dsd_buffer_size =
      DSD_BUFFER_SIZE;  
  float filter_q = 0.5f; //1.41f;
  float filter_cutoff = 0.4f;  
  int output_buffer_size = 1024;
};
struct DSFMetadata : public AudioInfo {…};
 
struct __attribute__((packed)) DSDPrefix {
  char id[4];               // "DSD "
  uint64_t chunkSize;       // 28
  uint64_t fileSize;        // total file size
  uint64_t metadataOffset;  // offset to "ID3 " chunk (0 if none)
};
  {…}
 
struct __attribute__((packed)) DSFFormat {
  char id[4];                    // "fmt "
  uint64_t chunkSize;            // 52
  uint32_t formatVersion;        // 1
  uint32_t formatID;             // 0
  uint32_t channelType;          // e.g., 2 for stereo
  uint32_t channelNum;           // number of channels
  uint32_t samplingFrequency;    // e.g., 2822400
  uint32_t bitsPerSample;        // 1
  uint64_t sampleCount;          // total samples per channel
  uint32_t blockSizePerChannel;  // e.g., 4096
  uint32_t reserved;             // 0
};
 
struct __attribute__((packed)) DSFDataHeader {
  char id[4];          // "data"
  uint64_t chunkSize;  // size of DSD data
  // followed by: uint8_t rawData[chunkSize];
};
 
class DSFDecoder : public AudioDecoder {
 public:
  DSFDecoder() = default;
  DSFDecoder(DSFMetadata metaData) { setMetaData(metaData); };
 
  AudioInfo audioInfo() override { return meta; }
 
  void setAudioInfo(AudioInfo from) override {
    TRACED();
    AudioDecoder::setAudioInfo(from);
    meta.copyFrom(from);
    if (isHeaderAvailable()){
      // Ensure PCM buffer is allocated based on the new audio info
      int buffer_size = getOutputBufferSize();
      pcmBuffer.resize(buffer_size);
      channelAccum.resize(meta.channels);
      channelIntegrator.resize(meta.channels);
 
      setupTargetPCMRate();
      setupDecimationStep();
    }
  }
  void setAudioInfo(AudioInfo from) override  {…}
 
  bool begin() {
    TRACED();
    dsdBuffer.resize(meta.dsd_buffer_size);
    dsdBuffer.reset();
    headerParsed = false;
    headerSize = 0;
    dataSize = 0;
    filePos = 0;
    decimationStep = 64;
    max_value = 0;
 
    // update decimaten step & filter parameters
    isActive = true;
 
    return true;
  }
  bool begin() {…}
 
  void end() override { isActive = false; }
 
  const DSFMetadata getMetadata() { return meta; }
 
  void setMetaData(DSFMetadata metaData) {
    meta = metaData;
    AudioDecoder::setAudioInfo(meta);
  }
 
  bool isHeaderAvailable() { return headerParsed; }
 
  operator bool() { return isActive; }
 
  size_t write(const uint8_t* data, size_t len) {
    LOGD("write: %u", (unsigned)len);
    size_t i = 0;
 
    // Phase 1: Parse DSF header to extract format information
    i += processHeader(data, len, i);
 
    // Phase 2: Process audio data (buffer DSD + convert to PCM)
    if (headerParsed && i < len) {
      i += processDSDData(data, len, i);
    }
 
    return len;  // Always report full consumption for streaming compatibility
  }
  size_t write(const uint8_t* data, size_t len) {…}
 
 protected:
  // Header parsing state
  size_t headerSize;          
  bool headerParsed = false;  
  bool isActive = false;  
  uint64_t dataSize;      
  size_t filePos;         
 
  // Processing buffers and state
  SingleBuffer<uint8_t> pcmBuffer{0};  
  Vector<float> channelAccum;  
  Vector<LowPassFilter<float>>
      channelFilters;                
  RingBuffer<uint8_t> dsdBuffer{0};  
  uint32_t decimationStep;  
  Vector<float> channelIntegrator;  
 
  // Metadata
  DSFMetadata meta;  
  float max_value = 0.0f;
 
  int getOutputBufferSize() {
    int frame_size = meta.bits_per_sample / 8 * meta.channels;
    if (meta.bits_per_sample == 24) frame_size = 4 * meta.channels;
    int buffer_size = frame_size;
    if (meta.output_buffer_size > buffer_size)
      buffer_size = meta.output_buffer_size;
    return buffer_size;
  }
  int getOutputBufferSize() {…}
 
  size_t processHeader(const uint8_t* data, size_t len, size_t startPos) {
    if (headerParsed) return 0;
    LOGI("processHeader: %u (%u)", (unsigned)len, (unsigned)startPos);
 
    // Check for DSD header magic
    if (memcmp(data, "DSD ", 4) != 0) {
      LOGE("Invalid DSF header magic");
      return 0;
    }
 
    int dataPos = findTag("data", data, len);
    int fmtPos = findTag("fmt ", data, len);
    if (dataPos < 0 || fmtPos < 0) {
      LOGE("DSF header not found in data (fmt: %d, data: %d)", fmtPos, dataPos);
      return 0;  // No valid header found
    }
    // parse the data
    parseFMT(data + fmtPos, len - fmtPos);
    parseData(data + dataPos, len - dataPos);
    headerParsed = true;
 
    // update audio info and initialize filters
    setAudioInfo(meta);
 
    return dataPos + sizeof(DSFDataHeader);
  }
  size_t processHeader(const uint8_t* data, size_t len, size_t startPos) {…}
 
  size_t processDSDData(const uint8_t* data, size_t len, size_t startPos) {
    LOGD("processDSDData: %u (%u)", (unsigned)len, (unsigned)startPos);
    size_t bytesProcessed = 0;
 
    // Buffer as much DSD data as possible
    bytesProcessed += bufferDSDData(data, len, startPos);
 
    // Convert buffered DSD data to PCM output
    convertDSDToPCM();
 
    return bytesProcessed;
  }
  size_t processDSDData(const uint8_t* data, size_t len, size_t startPos) {…}
 
  size_t bufferDSDData(const uint8_t* data, size_t len, size_t startPos) {
    int write_len = len - startPos;
    if (write_len > dsdBuffer.availableForWrite()) {
      write_len = dsdBuffer.availableForWrite();
    }
    dsdBuffer.writeArray(data + startPos, write_len);
    filePos += write_len;
 
    return write_len;
  }
  size_t bufferDSDData(const uint8_t* data, size_t len, size_t startPos) {…}
 
  void convertDSDToPCM() {
    while (hasEnoughData()) {
      // Initialize accumulators
      for (int ch = 0; ch < meta.channels; ch++) {
        channelAccum[ch] = 0.0f;
      }
      // Initialize integrator states
      for (int ch = 0; ch < meta.channels; ch++) {
        channelIntegrator[ch] = 0.0f;
      }
 
      // Accumulate DSD samples over decimation period
      // DSF uses byte interleaving: bytes alternate between channels
      int bytesPerDecimationStep = decimationStep / 8;
      int samplesProcessed = 0;
 
      for (int i = 0; i < bytesPerDecimationStep && !dsdBuffer.isEmpty(); i++) {
        for (int ch = 0; ch < meta.channels && !dsdBuffer.isEmpty(); ch++) {
          uint8_t dsdByte;
          if (dsdBuffer.read(dsdByte)) {
            // Each byte contains 8 DSD samples for the current channel
            // Use integrator-based approach for better DSD conversion
            for (int bit = 0; bit < 8; bit++) {
              int channelBit = (dsdByte >> (7 - bit)) & 1;  // MSB first in DSF
 
              // Delta-sigma integration: accumulate the difference
              channelIntegrator[ch] += channelBit ? 1.0f : -1.0f;
 
              // Apply decay to prevent DC buildup
              channelIntegrator[ch] *= 0.9999f;
            }
 
            // Add integrated value to channel accumulator
            channelAccum[ch] += channelIntegrator[ch];
            samplesProcessed += 8;
          }
        }
      }
 
      float samplesPerChannel = samplesProcessed / meta.channels;
 
      if (samplesPerChannel > 0) {
        for (int ch = 0; ch < meta.channels; ch++) {
          // Normalize by sample count and apply scaling factor
          channelAccum[ch] = channelAccum[ch] / samplesPerChannel * 0.8f;
          if (meta.filter_cutoff > 0.0f &&
              meta.filter_q > 0.0f) {  // Only apply filter if configured
            // Apply low-pass filter to remove high-frequency noise
            channelAccum[ch] = channelFilters[ch].process(channelAccum[ch]);
          }
          //Serial.print(channelAccum[ch]);
          //Serial.print(" ");
 
          // Convert to PCM sample and store in buffer
          writePCMSample(clip(channelAccum[ch]));
        }
      }
 
      //Serial.println();
 
      // Output the PCM samples for all channels
      if (pcmBuffer.isFull()) {
        size_t frameSize = pcmBuffer.available();
        size_t written =
            getOutput()->write((uint8_t*)pcmBuffer.data(), frameSize);
        if (written != frameSize) {
          LOGE(
              "Failed to write PCM samples: expected %zu bytes, wrote %zu "
              "bytes",
              frameSize, written);
        }
        pcmBuffer.reset();
      }
    }
  }
  void convertDSDToPCM() {…}
 
  float clip(float value) {
    if (value > 1.0f) return 1.0f;
    if (value < -1.0f) return -1.0f;
    return value;
  }
  float clip(float value) {…}
 
  void setupTargetPCMRate() {
    TRACEI();
 
    // Initialize filters for the correct number of channels
    if (meta.sample_rate > 0 && meta.channels > 0) {
      float cutoffFreq =
          meta.sample_rate * meta.filter_cutoff;  // 40% of Nyquist frequency
      channelFilters.resize(meta.channels);
      for (int i = 0; i < meta.channels; i++) {
        channelFilters[i].begin(cutoffFreq, meta.sample_rate, meta.filter_q);
      }
    }
  }
  void setupTargetPCMRate() {…}
 
  void setupDecimationStep() {
    TRACEI();
    if (meta.sample_rate == 0 || meta.dsd_sample_rate == 0) {
      LOGE("Invalid sample rates: DSD=%u, PCM=%u",
           (unsigned)meta.dsd_sample_rate, (unsigned)meta.sample_rate);
      return;
    }
 
    decimationStep = meta.dsd_sample_rate / meta.sample_rate;
    if (decimationStep < 64) {
      LOGW("Decimation step %u too low, setting to 64",
           (unsigned)decimationStep);
      decimationStep = 64;
    }
    if (decimationStep > 512) {
      LOGW("Decimation step %u too high, setting to 512",
           (unsigned)decimationStep);
      decimationStep = 512;
    }
 
    // Ensure decimation step is multiple of 8 for clean byte processing
    decimationStep = (decimationStep / 8) * 8;
    if (decimationStep < 64) decimationStep = 64;
 
    LOGI("Decimation step set to %u for DSD rate %u and target PCM rate %u",
         (unsigned)decimationStep, (unsigned)meta.dsd_sample_rate,
         (unsigned)meta.sample_rate);
  }
  void setupDecimationStep() {…}
 
  bool hasEnoughData() {
    // DSF uses byte interleaving: each decimation step needs enough bytes
    // to cover all channels. Each byte contains 8 DSD samples for one
    // channel.
    int bytesPerDecimationStep = (decimationStep / 8) * meta.channels;
    if (bytesPerDecimationStep < meta.channels)
      bytesPerDecimationStep = meta.channels;
 
    return dsdBuffer.available() >= bytesPerDecimationStep;
  }
  bool hasEnoughData() {…}
 
  void writePCMSample(float filteredValue) {
    switch (meta.bits_per_sample) {
      case 8: {
        int8_t buffer8 = static_cast<int8_t>(filteredValue * 127.0f);
        pcmBuffer.write(buffer8);
        break;
      }
      case 16: {
        int16_t buffer16 = static_cast<int16_t>(filteredValue * 32767.0f);
        pcmBuffer.writeArray((uint8_t*)&buffer16, sizeof(int16_t));
        break;
      }
      case 24: {
        int24_t buffer24 =
            static_cast<int24_t>(filteredValue * 8388607.0f);  // 2^23 - 1
        pcmBuffer.writeArray((uint8_t*)&buffer24, sizeof(int24_t));
        break;
      }
      case 32: {
        int32_t buffer32 =
            static_cast<int32_t>(filteredValue * 2147483647.0f);  // 2^31 -
        pcmBuffer.writeArray((uint8_t*)&buffer32, sizeof(int32_t));
        break;
      }
      default:
        LOGE("Unsupported bits per sample: %d", meta.bits_per_sample);
        break;
    }
  }
  void writePCMSample(float filteredValue) {…}
 
  int findTag(const char* tag, const uint8_t* data, size_t len) {
    int taglen = strlen(tag);
    uint32_t* pt;
    for (int j = 0; j < len - taglen; j++) {
      if (memcmp(tag, data + j, taglen) == 0) {
        return j;  // Found the tag at position j
      }
    }
    return -1;
  }
  int findTag(const char* tag, const uint8_t* data, size_t len) {…}
 
  bool parseFMT(const uint8_t* data, size_t len) {
    TRACEI();
    if (len < sizeof(DSFFormat)) {
      LOGE("FMT section too short to parse DSF format header");
      return false;  // Not enough data to parse
    }
    DSFFormat* fmt = (DSFFormat*)data;
    meta.channels = fmt->channelNum;
    // Fallback to channel type if channels is 0
    if (meta.channels == 0) meta.channels = fmt->channelType;
    meta.dsd_sample_rate = fmt->samplingFrequency;
 
    // Validate channel count
    if (meta.channels == 0 || meta.channels > 8) {
      LOGE("Invalid channel count: %u (must be 1-8)", (unsigned)meta.channels);
      return false;
    }
 
    LOGI("channels: %u, DSD sample rate: %u", (unsigned)meta.channels,
         (unsigned)meta.dsd_sample_rate);
    return true;
  }
  bool parseFMT(const uint8_t* data, size_t len) {…}
 
  bool parseData(const uint8_t* data, size_t len) {
    TRACEI();
    if (len < sizeof(DSFDataHeader)) {
      LOGE("Data section too short to parse DSF data header");
      return false;  // Not enough data to parse
    }
    DSFDataHeader* header = (DSFDataHeader*)data;
    dataSize = header->chunkSize;
    meta.dsd_data_bytes = dataSize;
 
    uint64_t totalBits = dataSize * 8;
    uint64_t totalDSDSamples = totalBits / meta.channels;
    uint64_t totalPCMFrames =
        totalDSDSamples / (meta.dsd_sample_rate / meta.sample_rate);
    meta.pcm_frames = totalPCMFrames;
    meta.duration_sec = (float)totalPCMFrames / meta.sample_rate;
    return true;
  }
  bool parseData(const uint8_t* data, size_t len) {…}
};
class DSFDecoder : public AudioDecoder {…};
 
}  // namespace audio_tools