CodecWAV.h

Go to the documentation of this file.

#pragma once
 
#include "AudioTools/AudioCodecs/AudioCodecsBase.h"
#include "AudioTools/AudioCodecs/AudioEncoded.h"
#include "AudioTools/AudioCodecs/AudioFormat.h"
#include "AudioTools/CoreAudio/AudioBasic/StrView.h"
 
#define READ_BUFFER_SIZE 512
#define MAX_WAV_HEADER_LEN 200
#define MAX_WAV_HEADER_LEN_LIMIT 2048
#define WAV_ENCODER_COMPRESSED_CHUNK_SIZE 1024
 
namespace audio_tools {
 
struct WAVAudioInfo : AudioInfo {
  WAVAudioInfo() = default;
  WAVAudioInfo(const AudioInfo &from) {
    sample_rate = from.sample_rate;
    channels = from.channels;
    bits_per_sample = from.bits_per_sample;
  }
 
  AudioFormat format = AudioFormat::PCM;
  int byte_rate = 0;
  int block_align = 0;
  bool is_streamed = true;
  bool is_valid = false;
  uint32_t data_length = 0;
  uint32_t file_size = 0;
  int offset = 0;
  bool ext_adpcm_header = false;
};
 
static const char *wav_mime = "audio/wav";
 
static bool isADPCMFormat(AudioFormat format) {
  return format == AudioFormat::ADPCM || format == AudioFormat::DVI_ADPCM ||
         format == AudioFormat::YAMAHA_ADPCM;
}
 
class WAVHeader {
 public:
  WAVHeader() = default;
 
  int write(uint8_t *data, size_t data_len) {
    size_t needed = (size_t)buffer.available() + data_len;
    if (needed > buffer.size() && buffer.size() < MAX_WAV_HEADER_LEN_LIMIT) {
      size_t new_size = needed < (size_t)MAX_WAV_HEADER_LEN_LIMIT
                             ? needed
                             : (size_t)MAX_WAV_HEADER_LEN_LIMIT;
      buffer.resize(new_size);
    }
    return buffer.writeArray(data, data_len);
  }
 
  bool parse() {
    LOGI("WAVHeader::begin: %u", (unsigned)buffer.available());
    this->data_pos = 0l;
    memset((void *)&headerInfo, 0, sizeof(WAVAudioInfo));
 
    if (!setPos("RIFF")) return false;
    // RIFF stores chunk_size (= file_size - 8): normalize to full file size
    headerInfo.file_size = read_int32() + 8;
    if (!setPos("WAVE")) return false;
    if (!setPos("fmt ")) return false;
    int fmt_length = read_int32();
    headerInfo.format = (AudioFormat)read_int16();
    headerInfo.channels = read_int16();
    headerInfo.sample_rate = read_int32();
    headerInfo.byte_rate = read_int32();
    headerInfo.block_align = read_int16();
    headerInfo.bits_per_sample = read_int16();
    if (!setPos("data")) return false;
    headerInfo.data_length = read_int32();
    if (headerInfo.data_length == 0 || headerInfo.data_length >= 0x7fff0000) {
      headerInfo.is_streamed = true;
      headerInfo.data_length = ~0;
    }
 
    logInfo();
    buffer.clear();
    return true;
  }
 
  bool isDataComplete() {
    int pos = getDataPos();
    return pos > 0 && buffer.available() >= pos;
  }
 
  bool isOverflow() {
    return buffer.size() >= MAX_WAV_HEADER_LEN_LIMIT && !isDataComplete();
  }
 
  size_t available() { return buffer.available(); }
 
  int getDataPos() {
    int pos =
        StrView((char *)buffer.data(), MAX_WAV_HEADER_LEN, buffer.available())
            .indexOf("data");
    return pos > 0 ? pos + 8 : 0;
  }
 
  WAVAudioInfo &audioInfo() { return headerInfo; }
 
  void setAudioInfo(WAVAudioInfo info) { headerInfo = info; }
 
  bool writeHeader(Print *out) {
    return writeHeader(out, headerInfo);
  }
 
  bool writeHeader(Print *out, const WAVAudioInfo &info) {
    // reset first: buffer otherwise keeps accumulating bytes from earlier calls
    buffer.reset();
    writeRiffHeader(buffer, info);
    writeFMT(buffer, info);
    if (isADPCMFormat(info.format) && info.ext_adpcm_header) {
      writeFactChunk(buffer, info);
    }
    writeDataHeader(buffer, info);
    int len = buffer.available();
    int written = out->write(buffer.data(), len);
    if (written != len) {
      LOGE("Failed to write WAV header to output: written %d of %d bytes", written, len);
    }
    return written == len;
  }
 
  static int extraHeaderBytes(const WAVAudioInfo &info) {
    if (!info.ext_adpcm_header) return 0;
    switch (info.format) {
      case AudioFormat::ADPCM:      // MS ADPCM: 34 byte fmt extension + 12 byte fact chunk
        return 34 + 12;
      case AudioFormat::DVI_ADPCM:  // IMA/DVI ADPCM: 4 byte fmt extension + 12 byte fact chunk
        return 4 + 12;
      default:
        return 0;
    }
  }
 
  void clear() {
    data_pos = 0;
    WAVAudioInfo empty;
    empty.sample_rate = 0;
    empty.channels = 0;
    empty.bits_per_sample = 0;
    headerInfo = empty;
    buffer.setClearWithZero(true);
    buffer.reset();
  }
 
  void dumpHeader() {
    char msg[buffer.available() + 1];
    memset(msg, 0, buffer.available() + 1);
    for (int j = 0; j < buffer.available(); j++) {
      char c = (char)buffer.data()[j];
      if (!isalpha(c)) {
        c = '.';
      }
      msg[j] = c;
    }
    LOGI("Header: %s", msg);
  }
 
 protected:
  WAVAudioInfo headerInfo;
  SingleBuffer<uint8_t> buffer{MAX_WAV_HEADER_LEN};
  size_t data_pos = 0;
 
  bool setPos(const char *id) {
    int id_len = strlen(id);
    int pos = indexOf(id);
    if (pos < 0) return false;
    data_pos = pos + id_len;
    return true;
  }
 
  int indexOf(const char *str) {
    return StrView((char *)buffer.data(), MAX_WAV_HEADER_LEN,
                   buffer.available())
        .indexOf(str);
  }
 
  uint32_t read_tag() {
    uint32_t tag = 0;
    tag = (tag << 8) | getChar();
    tag = (tag << 8) | getChar();
    tag = (tag << 8) | getChar();
    tag = (tag << 8) | getChar();
    return tag;
  }
 
  uint32_t getChar32() { return getChar(); }
 
  uint32_t read_int32() {
    uint32_t value = 0;
    value |= getChar32() << 0;
    value |= getChar32() << 8;
    value |= getChar32() << 16;
    value |= getChar32() << 24;
    return value;
  }
 
  uint16_t read_int16() {
    uint16_t value = 0;
    value |= getChar() << 0;
    value |= getChar() << 8;
    return value;
  }
 
  void skip(int n) {
    int i;
    for (i = 0; i < n; i++) getChar();
  }
 
  int getChar() {
    if (data_pos < buffer.size())
      return buffer.data()[data_pos++];
    else
      return -1;
  }
 
  void seek(long int offset, int origin) {
    if (origin == SEEK_SET) {
      data_pos = offset;
    } else if (origin == SEEK_CUR) {
      data_pos += offset;
    }
  }
 
  size_t tell() { return data_pos; }
 
  bool eof() { return data_pos >= buffer.size() - 1; }
 
  void logInfo() {
    LOGI("WAVHeader sound_pos: %d", getDataPos());
    LOGI("WAVHeader channels: %d ", headerInfo.channels);
    LOGI("WAVHeader bits_per_sample: %d", headerInfo.bits_per_sample);
    LOGI("WAVHeader sample_rate: %d ", (int)headerInfo.sample_rate);
    LOGI("WAVHeader format: %d", (int)headerInfo.format);
  }
 
  void writeRiffHeader(BaseBuffer<uint8_t> &buffer,
                       const WAVAudioInfo &info) {
    buffer.writeArray((uint8_t *)"RIFF", 4);
    // chunk_size = file_size - 8 (RIFF header size)
    uint32_t chunk_size = info.file_size > 8 ? info.file_size - 8 : 0;
    LOGI("writeRiffHeader: file_size=%u riff_size=%u", info.file_size, chunk_size);
    write32(buffer, chunk_size);
    buffer.writeArray((uint8_t *)"WAVE", 4);
  }
 
  void writeFMT(BaseBuffer<uint8_t> &buffer, const WAVAudioInfo &info) {
    bool is_ms_adpcm = info.ext_adpcm_header && info.format == AudioFormat::ADPCM;
    bool is_ima_adpcm = info.ext_adpcm_header && info.format == AudioFormat::DVI_ADPCM;
    uint16_t fmt_len = 16;
    if (is_ima_adpcm) fmt_len = 20;
    else if (is_ms_adpcm) fmt_len = 50;
 
    uint16_t spb = samplesPerBlock(info);
    uint32_t byte_rate = info.byte_rate;
    // use the real average byte rate for ADPCM formats whenever the block
    // layout is known, regardless of whether the extended 'fmt '/'fact'
    // chunk is written: byte_rate is informational (e.g. used by some
    // players for scrubbing/duration estimates) and the linear-PCM-based
    // default in info.byte_rate is misleading for compressed formats
    if (isADPCMFormat(info.format) && spb > 0 && info.block_align > 0) {
      // average bytes/sec = (sample_rate * block_align) / samples_per_block
      byte_rate = ((uint64_t)info.sample_rate * info.block_align) / spb;
    }
 
    // wBitsPerSample for ADPCM formats is the number of bits per *coded*
    // sample (always 4 for MS/IMA WAV ADPCM), not the decoded PCM depth
    // tracked in info.bits_per_sample (typically 16) - writing 16 here
    // makes strict decoders (e.g. ffmpeg) reject the stream since it is
    // outside the codec's valid range
    uint16_t bits_per_coded_sample =
        isADPCMFormat(info.format) ? 4 : info.bits_per_sample;
 
    buffer.writeArray((uint8_t *)"fmt ", 4);
    write32(buffer, fmt_len);
    write16(buffer, (uint16_t)info.format);
    write16(buffer, info.channels);
    write32(buffer, info.sample_rate);
    write32(buffer, byte_rate);
    write16(buffer, info.block_align);  // frame size
    write16(buffer, bits_per_coded_sample);
 
    if (is_ima_adpcm) {
      write16(buffer, 2);    // cbSize: size of extra format bytes
      write16(buffer, spb);  // wSamplesPerBlock
    } else if (is_ms_adpcm) {
      // standard MS ADPCM coefficient table (7 predictor pairs)
      static const int16_t ms_adpcm_coef[7][2] = {
          {256, 0}, {512, -256}, {0, 0}, {192, 64},
          {240, 0}, {460, -208}, {392, -232}};
      write16(buffer, 32);   // cbSize: size of extra format bytes
      write16(buffer, spb);  // wSamplesPerBlock
      write16(buffer, 7);    // wNumCoef
      for (auto &c : ms_adpcm_coef) {
        write16(buffer, (uint16_t)c[0]);
        write16(buffer, (uint16_t)c[1]);
      }
    }
  }
 
  void writeFactChunk(BaseBuffer<uint8_t> &buffer, const WAVAudioInfo &info) {
    buffer.writeArray((uint8_t *)"fact", 4);
    write32(buffer, 4);  // chunk size
    uint32_t sample_length = 0;
    uint16_t spb = samplesPerBlock(info);
    if (!info.is_streamed && spb > 0 && info.block_align > 0) {
      sample_length = (info.data_length / info.block_align) * spb;
    }
    write32(buffer, sample_length);
  }
 
  void writeDataHeader(BaseBuffer<uint8_t> &buffer, const WAVAudioInfo &info) {
    buffer.writeArray((uint8_t *)"data", 4);
    uint32_t data_length = info.data_length;
    uint32_t header_bytes = 36 + extraHeaderBytes(info);
    if (headerInfo.is_streamed && data_length == 0) {
      data_length = ~0;  // use max value for streamed data if not set
    }
    if (!headerInfo.is_streamed && info.file_size >= header_bytes && (data_length == 0 || data_length == ~0)) {
      data_length = info.file_size - header_bytes;  // data length = file size - header size
    }
    LOGI("writeDataHeader: data_length=%u", data_length);
    write32(buffer, data_length);
    int offset = info.offset;
    if (offset > 0) {
      uint8_t empty[offset];
      memset(empty, 0, offset);
      buffer.writeArray(empty, offset);  // resolve issue with wrong aligment
    }
  }
 
  static uint16_t samplesPerBlock(const WAVAudioInfo &info) {
    if (info.channels <= 0 || info.block_align <= 0) return 0;
    switch (info.format) {
      case AudioFormat::ADPCM:  // MS ADPCM
        return ((info.block_align / info.channels) - 7) * 2 + 2;
      case AudioFormat::DVI_ADPCM:  // IMA/DVI ADPCM
        return ((info.block_align / info.channels) - 4) * 2 + 1;
      default:
        return 0;
    }
  }
 
  void write32(BaseBuffer<uint8_t> &buffer, uint64_t value) {
    buffer.writeArray((uint8_t *)&value, 4);
  }
 
  void write16(BaseBuffer<uint8_t> &buffer, uint16_t value) {
    buffer.writeArray((uint8_t *)&value, 2);
  }
 
};
 
class WAVDecoder : public AudioDecoder {
 
 public:
  WAVDecoder() = default;
 
  WAVDecoder(AudioDecoderExt &dec, AudioFormat fmt = AudioFormat::UNKNOWN) {
    setDecoder(dec, fmt);
  }
 
  void setDecoder(AudioDecoderExt &dec, AudioFormat fmt = AudioFormat::UNKNOWN) {
    TRACED();
    decoders.clear();
    addDecoder(dec, fmt);
  }
 
  void addDecoder(AudioDecoderExt &dec, AudioFormat fmt = AudioFormat::UNKNOWN) {
    TRACED();
    if (fmt == AudioFormat::UNKNOWN) fmt = dec.wavFormat();
    if (fmt == AudioFormat::UNKNOWN) {
      LOGE(
          "addDecoder: could not determine the WAV format tag for this "
          "decoder - please provide it explicitly");
      return;
    }
    for (int i = 0; i < decoders.size(); i++) {
      if (decoders[i].format == fmt) {
        decoders[i].decoder = &dec;
        return;
      }
    }
    decoders.push_back({fmt, &dec});
  }
 
  void setOutput(Print &out_stream) override { this->p_print = &out_stream; }
 
  bool begin() override {
    TRACED();
    header.clear();
    // close the decoder used for a previous stream (if any) before
    // selecting a new one for this stream: the match is only known once
    // the header has been parsed, so setupEncodedAudio() is triggered from
    // decodeHeader() instead of here
    endCurrentDecoder();
    byte_buffer.reset();
    buffer24.reset();
    buffer_float16.reset();
    isFirst = true;
    active = true;
    return true;
  }
 
  void end() override {
    TRACED();
    endCurrentDecoder();
    byte_buffer.reset();
    buffer24.reset();
    buffer_float16.reset();
    active = false;
  }
 
  const char *mime() { return wav_mime; }
 
  WAVAudioInfo &audioInfoEx() { return header.audioInfo(); }
 
  AudioInfo audioInfo() override {
    WAVAudioInfo info = header.audioInfo();
    if (convert8to16 && info.format == AudioFormat::PCM &&
        info.bits_per_sample == 8) {
      info.bits_per_sample = 16;
    }
    // 32 bits gives better result
    if (convert24 && info.format == AudioFormat::PCM &&
        info.bits_per_sample == 24) {
      info.bits_per_sample = 32;
    }
    // ALAW/MULAW are expanded from 8-bit logarithmic to 16-bit linear PCM
    if (convertALawMuLaw && (info.format == AudioFormat::ALAW ||
                              info.format == AudioFormat::MULAW)) {
      info.bits_per_sample = 16;
    }
    // IEEE_FLOAT can optionally be converted to 16-bit linear PCM
    if (convertFloatToInt16 && info.format == AudioFormat::IEEE_FLOAT &&
        info.bits_per_sample == 32) {
      info.bits_per_sample = 16;
    }
    // any other non-PCM/non-IEEE_FLOAT format (e.g. ADPCM) is decoded by
    // p_decoder to 16-bit PCM; IEEE_FLOAT is passed through as-is
    if (info.format != AudioFormat::PCM &&
        info.format != AudioFormat::IEEE_FLOAT &&
        info.format != AudioFormat::ALAW &&
        info.format != AudioFormat::MULAW) {
      info.bits_per_sample = 16;
    }
    return info;
  }
 
  virtual size_t write(const uint8_t *data, size_t len) override {
    TRACED();
    size_t result = 0;
    if (active) {
      if (isFirst) {
        int data_start = decodeHeader((uint8_t *)data, len);
        // we do not have the complete header yet: need more data
        if (data_start == 0) return len;
        // process the outstanding data - only if the format is supported;
        // otherwise report 0 bytes written, consistent with subsequent
        // write() calls once the format has been found to be invalid
        if (isValid) {
          result = data_start +
                   write_out((uint8_t *)data + data_start, len - data_start);
        }
 
      } else if (isValid) {
        result = write_out((uint8_t *)data, len);
      }
    }
    return result;
  }
 
  virtual operator bool() override { return active; }
 
  void setConvert8Bit(bool enable) {
    convert8to16 = enable;
  }
 
  void setConvert24Bit(bool enable) {
    convert24 = enable;
  }
 
  void setConvertALawMuLaw(bool enable) {
    convertALawMuLaw = enable;
  }
 
  void setConvertFloatToInt16(bool enable) {
    convertFloatToInt16 = enable;
  }
 
  WAVHeader &getHeader() { return header; }
 
 protected:
  struct DecoderEntry {
    AudioFormat format = AudioFormat::PCM;
    AudioDecoderExt *decoder = nullptr;
    DecoderEntry() = default;
    DecoderEntry(AudioFormat fmt, AudioDecoderExt *dec)
        : format(fmt), decoder(dec) {}
  };
 
  WAVHeader header;
  bool isFirst = true;
  bool isValid = true;
  bool active = false;
  AudioDecoderExt *p_decoder = nullptr;
  Vector<DecoderEntry> decoders;
  EncodedAudioOutput dec_out;
  SingleBuffer<uint8_t> byte_buffer{0};
  SingleBuffer<int32_t> buffer24{0};
  SingleBuffer<int16_t> buffer_float16{0};
  bool convert8to16 = true;  // Optional conversion flag
  bool convert24 = true;  // Optional conversion flag
  bool convertALawMuLaw = true;  // Optional conversion flag
  bool convertFloatToInt16 = true;  // Optional conversion flag
  const size_t batch_size = 256;
 
  Print &out() { return p_decoder == nullptr ? *p_print : dec_out; }
 
  virtual size_t write_out(const uint8_t *in_ptr, size_t in_size) {
    // check if we need to convert int24 data from 3 bytes to 4 bytes
    size_t result = 0;
    AudioFormat format = header.audioInfo().format;
    if (convert24 && format == AudioFormat::PCM &&
        header.audioInfo().bits_per_sample == 24 && sizeof(int24_t) == 4) {
      write_out_24(in_ptr, in_size);
      result = in_size;
    } else if (convert8to16 && format == AudioFormat::PCM &&
               header.audioInfo().bits_per_sample == 8) {
      result = write_out_8to16(in_ptr, in_size);
    } else if (convertALawMuLaw && format == AudioFormat::ALAW) {
      result = write_out_alaw(in_ptr, in_size);
    } else if (convertALawMuLaw && format == AudioFormat::MULAW) {
      result = write_out_mulaw(in_ptr, in_size);
    } else if (convertFloatToInt16 && format == AudioFormat::IEEE_FLOAT &&
               header.audioInfo().bits_per_sample == 32) {
      result = write_out_float_to_int16(in_ptr, in_size);
    } else {
      result = out().write(in_ptr, in_size);
    }
    return result;
  }
 
  size_t write_out_8to16(const uint8_t *in_ptr, size_t in_size) {
    size_t samples_remaining = in_size;
    size_t offset = 0;
    int16_t out_buf[batch_size];
    while (samples_remaining > 0) {
      size_t current_batch =
          samples_remaining > batch_size ? batch_size : samples_remaining;
      for (size_t i = 0; i < current_batch; ++i) {
        out_buf[i] = ((int16_t)in_ptr[offset + i] - 128) << 8;
      }
      writeDataT<int16_t>(&out(), out_buf, current_batch);
      offset += current_batch;
      samples_remaining -= current_batch;
    }
    return in_size;
  }
 
  size_t write_out_24(const uint8_t *in_ptr, size_t in_size) {
    // store 1 sample
    buffer24.resize(batch_size);
    byte_buffer.resize(3);
 
    for (size_t i = 0; i < in_size; i++) {
      // Add byte to buffer
      byte_buffer.write(in_ptr[i]);
      
      // Process complete sample when buffer is full
      if (byte_buffer.isFull()) {
        int24_3bytes_t sample24{byte_buffer.data()};
        int32_t converted_sample = sample24.scale32();
        buffer24.write(converted_sample);
        if (buffer24.isFull()) {
          writeDataT<int32_t>(&out(), buffer24.data(), buffer24.available());
          buffer24.reset();
        }
        byte_buffer.reset();
      }
    }
 
    return in_size;
  }
 
  size_t write_out_float_to_int16(const uint8_t *in_ptr, size_t in_size) {
    buffer_float16.resize(batch_size);
    byte_buffer.resize(4);
 
    for (size_t i = 0; i < in_size; i++) {
      byte_buffer.write(in_ptr[i]);
 
      if (byte_buffer.isFull()) {
        float sample_f;
        memcpy(&sample_f, byte_buffer.data(), sizeof(sample_f));
        if (sample_f > 1.0f) sample_f = 1.0f;
        if (sample_f < -1.0f) sample_f = -1.0f;
        buffer_float16.write((int16_t)(sample_f * 32767.0f));
        if (buffer_float16.isFull()) {
          writeDataT<int16_t>(&out(), buffer_float16.data(),
                               buffer_float16.available());
          buffer_float16.reset();
        }
        byte_buffer.reset();
      }
    }
 
    return in_size;
  }
 
  size_t write_out_alaw(const uint8_t *in_ptr, size_t in_size) {
    size_t remaining = in_size;
    size_t offset = 0;
    int16_t out_buf[batch_size];
    while (remaining > 0) {
      size_t current_batch =
          remaining > batch_size ? batch_size : remaining;
      for (size_t i = 0; i < current_batch; ++i) {
        out_buf[i] = alaw2linear(in_ptr[offset + i]);
      }
      writeDataT<int16_t>(&out(), out_buf, current_batch);
      offset += current_batch;
      remaining -= current_batch;
    }
    return in_size;
  }
 
  size_t write_out_mulaw(const uint8_t *in_ptr, size_t in_size) {
    size_t remaining = in_size;
    size_t offset = 0;
    int16_t out_buf[batch_size];
    while (remaining > 0) {
      size_t current_batch =
          remaining > batch_size ? batch_size : remaining;
      for (size_t i = 0; i < current_batch; ++i) {
        out_buf[i] = ulaw2linear(in_ptr[offset + i]);
      }
      writeDataT<int16_t>(&out(), out_buf, current_batch);
      offset += current_batch;
      remaining -= current_batch;
    }
    return in_size;
  }
 
  static int16_t alaw2linear(uint8_t a_val) {
    a_val ^= 0x55;
    int t = (a_val & 0x0f) << 4;
    int seg = ((unsigned)a_val & 0x70) >> 4;
    switch (seg) {
      case 0:
        t += 8;
        break;
      case 1:
        t += 0x108;
        break;
      default:
        t += 0x108;
        t <<= (seg - 1);
        break;
    }
    return (int16_t)((a_val & 0x80) ? t : -t);
  }
 
  static int16_t ulaw2linear(uint8_t u_val) {
    u_val = ~u_val;
    int t = ((u_val & 0x0f) << 3) + 0x84;
    t <<= ((unsigned)u_val & 0x70) >> 4;
    return (int16_t)((u_val & 0x80) ? (0x84 - t) : (t - 0x84));
  }
 
  int decodeHeader(uint8_t *in_ptr, size_t in_size) {
    // we expect at least the full header
    header.write(in_ptr, in_size);
    if (!header.isDataComplete()) {
      if (header.isOverflow()) {
        // the header (up to and including the 'data' chunk tag) exceeds
        // MAX_WAV_HEADER_LEN_LIMIT without ever completing - give up
        // instead of waiting forever for data that will never arrive
        LOGE(
            "WAV header exceeds the maximum supported size of %d bytes "
            "without a 'data' chunk - aborting",
            (int)MAX_WAV_HEADER_LEN_LIMIT);
        isFirst = false;
        isValid = false;
        return 0;
      }
      LOGW("WAV header misses 'data' section in len: %d",
           (int)header.available());
      header.dumpHeader();
      return 0;
    }
    // parse header
    if (!header.parse()) {
      LOGE("WAV header parsing failed");
      return 0;
    }
 
    isFirst = false;
 
    LOGI("WAV sample_rate: %d", (int)header.audioInfo().sample_rate);
    LOGI("WAV data_length: %u", (unsigned)header.audioInfo().data_length);
    LOGI("WAV is_streamed: %d", header.audioInfo().is_streamed);
 
    // select the decoder matching the format found in the header (if any
    // was registered via setDecoder()/addDecoder()); otherwise fall back to
    // the natively supported formats (PCM, IEEE_FLOAT, ALAW, MULAW)
    AudioFormat format = header.audioInfo().format;
    p_decoder = findDecoder(format);
    isValid = p_decoder != nullptr ? true : isNativelySupported(format);
    if (isValid) {
      if (p_decoder != nullptr) {
        // update blocksize before begin() is called in setupEncodedAudio()
        int block_size = header.audioInfo().block_align;
        p_decoder->setBlockSize(block_size);
        setupEncodedAudio();
      }
 
      // update sampling rate if the target supports it
      AudioInfo bi = audioInfo();
      notifyAudioChange(bi);
    } else {
      LOGE("WAV format not supported: 0x%04X", (unsigned)format);
      logSupportedFormats();
    }
    return header.getDataPos();
  }
 
  void logSupportedFormats() {
    LOGE(
        "Natively supported: PCM (0x%04X), IEEE_FLOAT (0x%04X), ALAW "
        "(0x%04X), MULAW (0x%04X)",
        (unsigned)AudioFormat::PCM, (unsigned)AudioFormat::IEEE_FLOAT,
        (unsigned)AudioFormat::ALAW, (unsigned)AudioFormat::MULAW);
    if (decoders.empty()) {
      LOGE(
          "No additional decoders registered - use "
          "setDecoder()/addDecoder() to support e.g. ADPCM formats");
    } else {
      for (int i = 0; i < decoders.size(); i++) {
        LOGE("Registered decoder for format: 0x%04X",
             (unsigned)decoders[i].format);
      }
    }
  }
 
  AudioDecoderExt *findDecoder(AudioFormat format) {
    for (int i = 0; i < decoders.size(); i++) {
      if (decoders[i].format == format) return decoders[i].decoder;
    }
    return nullptr;
  }
 
  void setupEncodedAudio() {
    if (p_decoder != nullptr) {
      assert(p_print != nullptr);
      dec_out.setOutput(p_print);
      dec_out.setDecoder(p_decoder);
      dec_out.begin(info);
    }
  }
 
  void endCurrentDecoder() {
    if (p_decoder != nullptr) {
      p_decoder->end();
      p_decoder = nullptr;
    }
  }
 
  static bool isNativelySupported(AudioFormat format) {
    return format == AudioFormat::PCM || format == AudioFormat::IEEE_FLOAT ||
           format == AudioFormat::ALAW || format == AudioFormat::MULAW;
  }
};
 
class CountingPrint : public Print {
 public:
  void setOutput(Print *out) { p_out = out; }
  size_t write(uint8_t c) override { return write(&c, 1); }
  size_t write(const uint8_t *data, size_t len) override {
    size_t written = p_out != nullptr ? p_out->write(data, len) : 0;
    count += written;
    return written;
  }
  size_t count = 0;
 
 protected:
  Print *p_out = nullptr;
};
 
class WAVEncoder : public AudioEncoder {
 public:
  WAVEncoder() = default;
 
  WAVEncoder(AudioEncoderExt &enc, AudioFormat fmt) { setEncoder(enc, fmt); };
 
  void setEncoder(AudioEncoderExt &enc, AudioFormat fmt) {
    TRACED();
    wav_info.format = fmt;
    p_encoder = &enc;
  }
 
  void setOutput(Print &out) override {
    TRACED();
    p_print = &out;
  }
 
  const char *mime() override { return wav_mime; }
 
  WAVAudioInfo defaultConfig() {
    WAVAudioInfo info;
    info.format = AudioFormat::PCM;
    info.sample_rate = DEFAULT_SAMPLE_RATE;
    info.bits_per_sample = DEFAULT_BITS_PER_SAMPLE;
    info.channels = DEFAULT_CHANNELS;
    info.is_streamed = true;
    info.is_valid = true;
    info.data_length = 0x7fff0000;
    info.file_size = info.data_length + 36;
    return info;
  }
 
  virtual void setAudioInfo(AudioInfo from) override {
    wav_info.sample_rate = from.sample_rate;
    wav_info.channels = from.channels;
    wav_info.bits_per_sample = from.bits_per_sample;
    // recalculate byte rate, block align...
    setAudioInfo(wav_info);
  }
 
  virtual void setAudioInfo(WAVAudioInfo ai) {
    AudioEncoder::setAudioInfo(ai);
    if (p_encoder) p_encoder->setAudioInfo(ai);
    wav_info = ai;
    LOGI("sample_rate: %d", (int)wav_info.sample_rate);
    LOGI("channels: %d", wav_info.channels);
    LOGI("bits_per_sample: %d", wav_info.bits_per_sample);
    // bytes per second
    wav_info.byte_rate = wav_info.sample_rate * wav_info.channels *
                          wav_info.bits_per_sample / 8;
    // uncompressed formats with a fixed size per sample: block_align is
    // simply the frame size. Compressed formats (e.g. ADPCM) are handled
    // via p_encoder instead.
    if (wav_info.format == AudioFormat::PCM ||
        wav_info.format == AudioFormat::IEEE_FLOAT ||
        wav_info.format == AudioFormat::ALAW ||
        wav_info.format == AudioFormat::MULAW) {
      wav_info.block_align =
          wav_info.bits_per_sample / 8 * wav_info.channels;
    }
    applyPendingOverrides();
  }
 
  bool begin(WAVAudioInfo ai) {
    setAudioInfo(ai);
    return begin();
  }
 
  virtual bool begin() override {
    TRACED();
    header.clear();
    if (!setupEncodedAudio()) {
      is_open = false;
      return false;
    }
 
    // normalize streaming mode and payload limits at start time
    if (wav_info.is_streamed || wav_info.data_length == 0 ||
        wav_info.data_length >= 0x7fff0000) {
      LOGI("is_streamed! because length is %u",
           (unsigned)wav_info.data_length);
      wav_info.is_streamed = true;
      wav_info.data_length = ~0;
      size_limit = 0;
    } else {
      wav_info.is_streamed = false;
      size_limit = wav_info.data_length;
      LOGI("size_limit is %d", (int)size_limit);
    }
 
    header_written = false;
    is_open = true;
    return true;
  }
 
  void end() override { is_open = false; }
 
  virtual size_t write(const uint8_t *data, size_t len) override {
    if (!is_open) {
      LOGE("The WAVEncoder is not open - please call begin()");
      return 0;
    }
 
    if (p_print == nullptr) {
      LOGE("No output stream was provided");
      return 0;
    }
 
    if (!header_written) {
      LOGI("Writing Header");
      if (!header.writeHeader(p_print, wav_info)) {
        LOGE("Failed to write WAV header");
        is_open = false;
        return 0;
      }
      header_written = true;
    }
 
    size_t result = 0;
    Print *p_out = p_encoder == nullptr ? p_print : &enc_out;
 
    if (wav_info.is_streamed) {
      result = p_out->write((uint8_t *)data, len);
    } else if (size_limit > 0) {
      if (p_encoder == nullptr) {
        // uncompressed: input bytes map 1:1 to output bytes, so we can
        // truncate exactly at the declared data_length boundary
        size_t write_size = min((size_t)len, (size_t)size_limit);
        result = p_out->write((uint8_t *)data, write_size);
        size_limit -= result;
      } else {
        // compressed: the number of encoded bytes an external encoder
        // produces for a given amount of PCM input is not known in advance
        // (and may only be emitted once a full internal block is ready), so
        // AudioEncoder::write()'s return value (raw PCM input bytes
        // accepted) cannot be used to track progress towards data_length.
        // Track the *actual* encoded bytes written via counting_print, and
        // feed the encoder in frame-aligned chunks so we can stop as soon
        // as data_length is reached - result then correctly reflects only
        // the bytes of `data` that were actually consumed, so the caller
        // knows what still needs to be resent (e.g. to a new file).
        int frame_size = wav_info.bits_per_sample / 8 * wav_info.channels;
        if (frame_size <= 0) frame_size = 1;
        size_t chunk = (WAV_ENCODER_COMPRESSED_CHUNK_SIZE / frame_size) * frame_size;
        if (chunk == 0) chunk = frame_size;
 
        while (result < len && size_limit > 0) {
          size_t n = min(chunk, len - result);
          counting_print.count = 0;
          size_t accepted = p_out->write((uint8_t *)data + result, n);
          size_limit -= counting_print.count;
          result += accepted;
          if (accepted < n) break;  // encoder didn't accept the full chunk
        }
      }
 
      if (size_limit <= 0) {
        LOGI("The defined size was written - so we close the WAVEncoder now");
        is_open = false;
      }
    }
    return result;
  }
 
  operator bool() override { return is_open; }
 
  bool isOpen() { return is_open; }
 
  void setDataOffset(uint16_t offset) {
    has_pending_offset = true;
    pending_offset = offset;
    wav_info.offset = offset;
  }
 
  void setExtADPCMHeader(bool enable) {
    has_pending_ext_adpcm_header = true;
    pending_ext_adpcm_header = enable;
    wav_info.ext_adpcm_header = enable;
  }
 
  void setDataLength(uint32_t data_length) {
    has_pending_data_length = true;
    pending_data_length = data_length;
    applyPendingOverrides();
    setAudioInfo(wav_info);
  }
 
  WAVAudioInfo &audioInfoEx() { return wav_info; }
 
  WAVHeader &getHeader() { return header; }
 
 protected:
  WAVHeader header;
  Print *p_print = nullptr;  // final output  CopyEncoder copy; // used for PCM
  AudioEncoderExt *p_encoder = nullptr;
  EncodedAudioOutput enc_out;
  CountingPrint counting_print;
  WAVAudioInfo wav_info = defaultConfig();
  int64_t size_limit = 0;
  bool header_written = false;
  volatile bool is_open = false;
 
  // fields set via setDataLength()/setDataOffset()/setExtADPCMHeader() that
  // must survive a subsequent wholesale setAudioInfo(WAVAudioInfo)/
  // begin(WAVAudioInfo) call, regardless of call order - see
  // applyPendingOverrides()
  bool has_pending_data_length = false;
  uint32_t pending_data_length = 0;
  bool has_pending_offset = false;
  uint16_t pending_offset = 0;
  bool has_pending_ext_adpcm_header = false;
  bool pending_ext_adpcm_header = false;
 
  void applyPendingOverrides() {
    // must run before pending_data_length below: its file_size calculation
    // depends on wav_info.ext_adpcm_header
    if (has_pending_ext_adpcm_header) {
      wav_info.ext_adpcm_header = pending_ext_adpcm_header;
    } else if (p_encoder != nullptr && isADPCMFormat(wav_info.format)) {
      // default to the extended header for ADPCM formats unless the user
      // explicitly overrode it via setExtADPCMHeader()
      wav_info.ext_adpcm_header = true;
    }
    if (has_pending_offset) {
      wav_info.offset = pending_offset;
    }
    if (has_pending_data_length) {
      wav_info.data_length = pending_data_length;
      wav_info.is_streamed =
          (pending_data_length == 0 || pending_data_length >= 0x7fff0000);
      if (!wav_info.is_streamed) {
        // full file size = RIFF chunk (36) + format specific extra header
        // bytes (e.g. ADPCM 'fmt ' extension + 'fact' chunk) + data chunk
        // payload
        wav_info.file_size = wav_info.data_length + 36 +
                              WAVHeader::extraHeaderBytes(wav_info);
      }
    }
  }
 
  bool setupEncodedAudio() {
    if (p_encoder != nullptr) {
      if (p_print == nullptr) {
        LOGE(
            "setupEncodedAudio: no output stream was provided - call "
            "setOutput() before begin()");
        return false;
      }
      counting_print.setOutput(p_print);
      counting_print.count = 0;
      enc_out.setOutput(&counting_print);
      enc_out.setEncoder(p_encoder);
      enc_out.setAudioInfo(wav_info);
      enc_out.begin();
      // block size only available after begin(): update block size
      wav_info.block_align = p_encoder->blockSize();
    }
    return true;
  }
};
 
}  // namespace audio_tools