VorbisDecoder.h

#pragma once
 
 
#include "AudioTools/AudioCodecs/AudioCodecsBase.h"
#include "AudioTools/CoreAudio/Buffers.h"
 
#include <vorbis.h>
 
namespace audio_tools {
 
class VorbisDecoder : public AudioDecoder {
 public:
  VorbisDecoder(size_t buffer_size = 256, int header_packets = 3)
      : pcm_buffer_size(buffer_size), num_header_packets(header_packets) {}
 
  ~VorbisDecoder() { end(); }
 
  bool begin() override {
    end();
    pcmout_buffer.resize(pcm_buffer_size);
    vorbis_info_init(&vi);
    vorbis_comment_init(&vc);
    active = true;
    return true;
  }
 
  void end() override {
    vorbis_block_clear(&vb);
    vorbis_dsp_clear(&vd);
    vorbis_comment_clear(&vc);
    vorbis_info_clear(&vi);
    header_packets = 0;
    decoder_initialized = false;
    active = false;
  }
 
  size_t write(const uint8_t *data, size_t len) override {
    ogg_packet packet;
    packet.packet = (unsigned char *)data;
    packet.bytes = len;
    packet.b_o_s = (header_packets == 0) ? 1 : 0;
    packet.e_o_s = 0;
    packet.granulepos = 0;
    packet.packetno = header_packets;
 
    if (num_header_packets == 0 && !decoder_initialized) {
      if (!initDecoder()) return 0;
      decoder_initialized = true;
    }
    if (header_packets < num_header_packets) {
      if (!parseHeaderPacket(packet, header_packets)) return 0;
      header_packets++;
      if (header_packets == num_header_packets) {
        if (!initDecoder()) return 0;
        decoder_initialized = true;
      }
      return 0;
    }
    if (header_packets == num_header_packets) {
      notifyAudioChange(audioInfo());
    }
    if (!decoder_initialized) return 0;
    return decodeAudioPacket(packet);
  }
 
  AudioInfo audioInfo() override {
    AudioInfo info;
    if (vi.channels > 0 && vi.rate > 0) {
      info.sample_rate = vi.rate;
      info.channels = vi.channels;
      info.bits_per_sample = 16;
    }
    return info;
  }
 
  operator bool() override { return active; }
 
 protected:
  vorbis_info vi{};
  vorbis_comment vc{};
  vorbis_dsp_state vd{};
  vorbis_block vb{};
  Print *p_print = nullptr;
  bool active = false;
  size_t pcm_buffer_size = 256;
  int num_header_packets = 3;
  Vector<int16_t> pcmout_buffer;
  int header_packets = 0;
  bool decoder_initialized = false;
  bool parseHeaderPacket(ogg_packet &packet, int header_packets) {
    if (vorbis_synthesis_headerin(&vi, &vc, &packet) != 0) {
      LOGE("Header packet %d invalid", header_packets);
      return false;
    }
    return true;
  }
 
  bool initDecoder() {
    if (vorbis_synthesis_init(&vd, &vi) != 0) {
      LOGE("vorbis_synthesis_init failed");
      return false;
    }
    vorbis_block_init(&vd, &vb);
    return true;
  }
 
  size_t decodeAudioPacket(ogg_packet &packet) {
    size_t total_written = 0;
    if (vorbis_synthesis(&vb, &packet) == 0) {
      vorbis_synthesis_blockin(&vd, &vb);
      float **pcm = nullptr;
      int samples = vorbis_synthesis_pcmout(&vd, &pcm);
      while (samples > 0 && pcm) {
        int chunk = (samples > pcm_buffer_size) ? pcm_buffer_size : samples;
        convertFloatToInt16PCM(pcm, chunk, vi.channels);
        if (!pcmout_buffer.empty() && p_print) {
          p_print->write((uint8_t *)pcmout_buffer.data(),
                         pcmout_buffer.size() * sizeof(int16_t));
          total_written += pcmout_buffer.size() * sizeof(int16_t);
          pcmout_buffer.clear();
        }
        vorbis_synthesis_read(&vd, chunk);
        samples = vorbis_synthesis_pcmout(&vd, &pcm);
      }
    }
    return total_written;
  }
 
  void convertFloatToInt16PCM(float **pcm, int samples, int channels) {
    for (int i = 0; i < samples; ++i) {
      for (int ch = 0; ch < channels; ++ch) {
        float val = pcm[ch][i];
        int16_t sample = (int16_t)(val * 32767.0f);
        if (sample > 32767) sample = 32767;
        if (sample < -32768) sample = -32768;
        pcmout_buffer.push_back(sample);
      }
    }
  }
};
 
}  // namespace audio_tools