write_samples WIP

src/internal_modules/roc_audio/target_libvorbis/roc_audio/vorbis_encoder.cpp

@@ -8,6 +8,7 @@
 
 #include "roc_audio/vorbis_encoder.h"
 #include "roc_core/panic.h"
+#include <iostream>
 
 namespace roc {
 namespace audio {
@@ -18,9 +19,9 @@ VorbisEncoder::VorbisEncoder(const SampleSpec& sample_spec)
     , frame_size_(0) {
     vorbis_info_init(&vorbis_info_);
 
-    const int num_channels = static_cast<int>(sample_spec.num_channels());
-    const int sample_rate = static_cast<int>(sample_spec.sample_rate());
-    int ret = vorbis_encode_init_vbr(&vorbis_info_, num_channels, sample_rate, 0.0f);
+    const long num_channels = static_cast<long>(sample_spec.num_channels());
+    const long sample_rate = static_cast<long>(sample_spec.sample_rate());
+    int ret = vorbis_encode_init_vbr(&vorbis_info_, num_channels, sample_rate, 0.5f);
     if (ret != 0) {
         roc_panic("vorbis encoder: failed to initialize vorbis encoder");
     }
@@ -56,22 +57,16 @@ status::StatusCode VorbisEncoder::init_status() const {
 
 size_t VorbisEncoder::encoded_byte_count(size_t num_samples) const {
     if (!initialized_) {
+        roc_panic("vorbis encoder: encoder not initialized");
         return 0;
     }
 
-    if (vorbis_info_.rate <= 0 || vorbis_info_.channels <= 0
-        || vorbis_info_.bitrate_nominal <= 0) {
-        roc_panic("vorbis encoder: vorbis_info structure has invalid values");
-        return 0;
-    }
-
-    // Average number of bits used per sample, per channel.
-    const size_t bit_width = static_cast<size_t>(
-        (vorbis_info_.bitrate_nominal / vorbis_info_.rate) / vorbis_info_.channels);
+    const size_t channels = static_cast<size_t>(vorbis_info_.channels);
+    // const size_t sample_rate = static_cast<size_t>(vorbis_info_.rate);
+    // const size_t bitrate_nominal = static_cast<size_t>(vorbis_info_.bitrate_nominal);
 
-    const size_t encoded_bytes = (num_samples * bit_width + 7) / 8;
-
-    return encoded_bytes;
+    size_t estimated_bytes = (32 * num_samples * channels) / (8);
+    return estimated_bytes;
 }
 
 void VorbisEncoder::begin_frame(void* frame_data, size_t frame_size) {
@@ -84,12 +79,95 @@ void VorbisEncoder::begin_frame(void* frame_data, size_t frame_size) {
 }
 
 size_t VorbisEncoder::write_samples(const sample_t* samples, size_t n_samples) {
-    roc_panic("TODO");
-    return 0;
+    if (!initialized_) {
+        roc_panic("vorbis encoder: encoder not initialized");
+        return 0;
+    }
+
+    if (!samples || n_samples == 0) {
+        return 0;
+    }
+
+    buffer_samples_(samples, n_samples);
+
+    size_t total_bytes_written = process_analysis_and_encoding_();
+
+    vorbis_analysis_wrote(&vorbis_dsp_, 0);
+
+    total_bytes_written += process_analysis_and_encoding_();
+
+    return total_bytes_written;
 }
 
 void VorbisEncoder::end_frame() {
-    roc_panic("TODO");
+    frame_data_ = NULL;
+    frame_size_ = 0;
+}
+
+void VorbisEncoder::buffer_samples_(const sample_t* samples, size_t n_samples) {
+    const int int_n_samples = static_cast<int>(n_samples);
+
+    float** buffer = vorbis_analysis_buffer(&vorbis_dsp_, int_n_samples);
+
+    for (int i = 0; i < int_n_samples; ++i) {
+        for (int ch = 0; ch < vorbis_info_.channels; ++ch) {
+            buffer[ch][i] = samples[i * vorbis_info_.channels + ch];
+        }
+    }
+
+    vorbis_analysis_wrote(&vorbis_dsp_, int_n_samples);
+}
+
+size_t VorbisEncoder::process_analysis_and_encoding_() {
+    size_t total_bytes_written = 0;
+
+    while (vorbis_analysis_blockout(&vorbis_dsp_, &vorbis_block_) == 1) {
+        vorbis_analysis(&vorbis_block_, NULL);
+
+        vorbis_bitrate_addblock(&vorbis_block_);
+
+        total_bytes_written += extract_and_write_packets_();
+    }
+
+    return total_bytes_written;
+}
+
+size_t VorbisEncoder::extract_and_write_packets_() {
+    size_t bytes_written = 0;
+
+    ogg_packet packet;
+    while (vorbis_bitrate_flushpacket(&vorbis_dsp_, &packet)) {
+        ogg_stream_packetin(&ogg_stream_, &packet);
+
+        bytes_written += write_ogg_pages_();
+    }
+
+    return bytes_written;
+}
+
+size_t VorbisEncoder::write_ogg_pages_() {
+    long bytes_written = 0;
+
+    ogg_page page;
+    while (ogg_stream_pageout(&ogg_stream_, &page)) {
+        if (bytes_written + page.header_len + page.body_len
+            > static_cast<long>(frame_size_)) {
+            roc_panic("vorbis encoder: frame buffer overflow");
+        }
+
+        write_to_frame_(page.header, page.header_len, bytes_written);
+        bytes_written += page.header_len;
+
+        write_to_frame_(page.body, page.body_len, bytes_written);
+        bytes_written += page.body_len;
+    }
+
+    return static_cast<size_t>(bytes_written);
+}
+
+void VorbisEncoder::write_to_frame_(const void* data, long size, long offset) {
+    const size_t casted_size = static_cast<size_t>(size);
+    memcpy(static_cast<uint8_t*>(frame_data_) + offset, data, casted_size);
 }
 
 } // namespace audio

src/internal_modules/roc_audio/target_libvorbis/roc_audio/vorbis_encoder.h

@@ -7,13 +7,14 @@
  */
 
 //! @file roc_audio/target_libvorbis/roc_audio/vorbis_encoder.h
-//! @brief Vorbis audio decoder.
+//! @brief Vorbis audio encoder.
 
 #ifndef ROC_AUDIO_VORBIS_ENCODER_H_
 #define ROC_AUDIO_VORBIS_ENCODER_H_
 
 #include "roc_audio/iframe_encoder.h"
 #include "roc_audio/sample_spec.h"
+#include <vorbis/codec.h>
 #include <vorbis/vorbisenc.h>
 
 namespace roc {
@@ -44,6 +45,12 @@ class VorbisEncoder : public IFrameEncoder {
     virtual void end_frame();
 
 private:
+    void buffer_samples_(const sample_t* samples, size_t n_samples);
+    size_t process_analysis_and_encoding_();
+    size_t extract_and_write_packets_();
+    size_t write_ogg_pages_();
+    void write_to_frame_(const void* data, long size, long offset);
+
     bool initialized_;
     void* frame_data_;
     size_t frame_size_;