AudioProcesspr: Implemented working ogg reading and writing

However, loop points were incorrectly converted and it's need to adjust them in slightly different way.

Author: Wohlstand

_common/AudioProcessor/audio_processor.cpp

@@ -18,14 +18,46 @@
  */
 
 #include "audio_processor.h"
+#include "codec/audio_vorbis.h"
+
 #include <SDL2/SDL.h>
 
 
+bool MoondustAudioProcessor::init_cvt_stream()
+{
+    const auto &source = m_in_file->getSpec();
+    const auto &obtained = m_out_file->getSpec();
+
+    if(m_cvt_stream)
+        SDL_FreeAudioStream(m_cvt_stream);
+
+    m_cvt_stream = SDL_NewAudioStream(source.m_sample_format, source.m_channels, source.m_sample_rate,
+                                      obtained.m_sample_format, obtained.m_channels, obtained.m_sample_rate);
+    if(!m_cvt_stream)
+    {
+        close();
+        return false;
+    }
+
+    size_t sample_in = (SDL_AUDIO_BITSIZE(source.m_sample_format) / 8) * source.m_channels;
+    size_t sample_out = (SDL_AUDIO_BITSIZE(obtained.m_sample_format) / 8) * obtained.m_channels;
+
+    m_in_buffer.resize(MD_AUDIO_CHUNK_SIZE * sample_in);
+    m_out_buffer.resize(MD_AUDIO_CHUNK_SIZE * sample_out);
+
+    m_numChunks = m_in_buffer.size() / sample_in;
+    m_curChunk = 0;
+
+    return true;
+}
+
 MoondustAudioProcessor::MoondustAudioProcessor()
 {}
 
 MoondustAudioProcessor::~MoondustAudioProcessor()
-{}
+{
+    close();
+}
 
 std::string MoondustAudioProcessor::getLastError() const
 {
@@ -39,12 +71,93 @@ const MDAudioFileSpec &MoondustAudioProcessor::getInSpec() const
 
 bool MoondustAudioProcessor::openInFile(const std::string &file, int *detectedFormat)
 {
-    return false;
+    m_in_file.reset(new MDAudioVorbis);
+    if(m_rw_in)
+        SDL_RWclose(m_rw_in);
+
+    m_rw_in = SDL_RWFromFile(file.c_str(), "rb");
+    if(!m_rw_in)
+    {
+        m_in_file.reset();
+        return false;
+    }
+
+    m_in_filePath = file;
+
+    if(!m_in_file->openRead(m_rw_in))
+    {
+        m_in_file.reset();
+        return false;
+    }
+
+    if(detectedFormat)
+        *detectedFormat = FORMAT_OGG_VORBIS;
+
+    return true;
 }
 
 bool MoondustAudioProcessor::openOutFile(const std::string &file, int dstFormat, const MDAudioFileSpec &dstSpec)
 {
-    return false;
+    if(!m_in_file.get())
+        return false;
+
+    m_out_file.reset(new MDAudioVorbis);
+    if(m_rw_out)
+        SDL_RWclose(m_rw_out);
+
+    m_rw_out = SDL_RWFromFile(file.c_str(), "wb");
+    if(!m_rw_out)
+    {
+        m_out_file.reset();
+        return false;
+    }
+
+    m_out_filePath = file;
+
+    if(!m_out_file->openWrite(m_rw_out, dstSpec))
+    {
+        m_out_file.reset();
+        return false;
+    }
+
+    if(!init_cvt_stream())
+        return false;
+
+    m_stat_read = 0;
+    m_stat_write = 0;
+
+    return true;
+}
+
+void MoondustAudioProcessor::close()
+{
+    if(m_out_file.get())
+    {
+        m_out_file->close();
+        m_out_file.reset();
+        SDL_RWclose(m_rw_out);
+        m_rw_out = nullptr;
+    }
+
+    if(m_in_file.get())
+    {
+        m_in_file->close();
+        m_in_file.reset();
+        SDL_RWclose(m_rw_in);
+        m_rw_in = nullptr;
+    }
+
+    if(m_cvt_stream)
+    {
+        SDL_FreeAudioStream(m_cvt_stream);
+        m_cvt_stream = nullptr;
+    }
+
+    m_in_filePath.clear();
+    m_out_filePath.clear();
+    m_done = false;
+    m_numChunks = 0;
+    m_curChunk = 0;
 }
 
 uint32_t MoondustAudioProcessor::numChunks() const
@@ -57,9 +170,82 @@ uint32_t MoondustAudioProcessor::curChunk() const
     return m_curChunk;
 }
 
+int64_t MoondustAudioProcessor::getBytesReadStat() const
+{
+    return m_stat_read;
+}
+
+int64_t MoondustAudioProcessor::getBytesWrittenStat() const
+{
+    return m_stat_write;
+}
+
+int64_t MoondustAudioProcessor::getSamplesReadStat() const
+{
+    const auto &source = m_in_file->getSpec();
+    size_t sample_in = (SDL_AUDIO_BITSIZE(source.m_sample_format) / 8) * source.m_channels;
+
+    return m_stat_read / sample_in;
+}
+
+int64_t MoondustAudioProcessor::getSamplesWrittenStat() const
+{
+    const auto &obtained = m_out_file->getSpec();
+    size_t sample_out = (SDL_AUDIO_BITSIZE(obtained.m_sample_format) / 8) * obtained.m_channels;
+
+    return m_stat_write / sample_out;
+}
+
 bool MoondustAudioProcessor::runChunk()
 {
-    return false;
+    int filled = 0, amount = 0, written = 0, attempts = 10;
+    bool spec_changed = false;
+
+    do
+    {
+        filled = SDL_AudioStreamGet(m_cvt_stream, m_out_buffer.data(), m_out_buffer.size());
+        if(filled != 0)
+            break;
+
+        amount = m_in_file->readChunk(m_in_buffer.data(), m_in_buffer.size(), &spec_changed);
+
+        if(amount == ~(size_t)0)
+            return false;
+
+        if(spec_changed) // Re-Init streamer
+        {
+            if(!init_cvt_stream())
+                return false;
+        }
+
+        if(amount > 0)
+        {
+            m_stat_read += amount;
+            m_curChunk++;
+            if(SDL_AudioStreamPut(m_cvt_stream, m_in_buffer.data(), amount) < 0)
+                return false;
+        }
+        else
+        {
+            SDL_AudioStreamFlush(m_cvt_stream);
+            attempts--;
+            if(attempts < 0)
+            {
+                m_done = true;
+                return true;
+            }
+        }
+
+    } while(filled == 0);
+
+    written = m_out_file->writeChunk(m_out_buffer.data(), filled);
+
+    if(written == 0)
+        return false;
+
+    m_stat_write += written;
+
+    return true;
 }
 
 bool MoondustAudioProcessor::done() const

_common/AudioProcessor/audio_processor.h

@@ -31,18 +31,21 @@ struct SDL_RWops;
 struct _SDL_AudioStream;
 typedef struct _SDL_AudioStream SDL_AudioStream;
 
-#define MD_AUDIO_CHUNK_SIZE 4096
+#define MD_AUDIO_CHUNK_SIZE 1024
 
 class MoondustAudioProcessor
 {
     std::string m_lastError;
     std::vector<uint8_t> m_in_buffer;
     std::vector<uint8_t> m_out_buffer;
 
+    SDL_RWops *m_rw_in = nullptr;
+    SDL_RWops *m_rw_out = nullptr;
     std::unique_ptr<MDAudioFile> m_in_file;
     std::unique_ptr<MDAudioFile> m_out_file;
 
-    SDL_AudioStream *m_cvt_stream;
+    SDL_AudioStream *m_cvt_stream = nullptr;
+    bool init_cvt_stream();
 
     uint32_t m_curChunk = 0;
     uint32_t m_numChunks = 0;
@@ -52,6 +55,9 @@ class MoondustAudioProcessor
     std::string m_in_filePath;
     std::string m_out_filePath;
 
+    int64_t m_stat_read = 0;
+    int64_t m_stat_write = 0;
+
 public:
     MoondustAudioProcessor();
     ~MoondustAudioProcessor();
@@ -63,9 +69,17 @@ class MoondustAudioProcessor
     bool openInFile(const std::string &file, int *detectedFormat = nullptr);
     bool openOutFile(const std::string &file, int dstFormat, const MDAudioFileSpec &dstSpec);
 
+    void close();
+
     uint32_t numChunks() const;
     uint32_t curChunk() const;
 
+    int64_t getBytesReadStat() const;
+    int64_t getBytesWrittenStat() const;
+
+    int64_t getSamplesReadStat() const;
+    int64_t getSamplesWrittenStat() const;
+
     bool runChunk();
 
     bool done() const;

_common/AudioProcessor/codec/audio_vorbis.cpp

@@ -54,6 +54,40 @@ bool MDAudioVorbis::updateSection()
     return true;
 }
 
+void MDAudioVorbis::writeFlush()
+{
+    int eos = 0;
+
+    while(vorbis_analysis_blockout(&m_vd, &m_vb) == 1)
+    {
+        /* analysis, assume we want to use bitrate management */
+        vorbis_analysis(&m_vb, nullptr);
+        vorbis_bitrate_addblock(&m_vb);
+
+        while(vorbis_bitrate_flushpacket(&m_vd, &m_op))
+        {
+            /* weld the packet into the bitstream */
+            ogg_stream_packetin(&m_os, &m_op);
+
+            /* write out pages (if any) */
+            while(!eos)
+            {
+                int result = ogg_stream_pageout(&m_os, &m_og);
+                if(result == 0)
+                    break;
+
+                SDL_RWwrite(m_file, m_og.header, 1, m_og.header_len);
+                SDL_RWwrite(m_file, m_og.body, 1, m_og.body_len);
+
+                /* this could be set above, but for illustrative purposes, I do
+                   it here (to show that vorbis does know where the stream ends) */
+                if(ogg_page_eos(&m_og))
+                    eos = 1;
+            }
+        }
+    }
+}
+
 MDAudioVorbis::MDAudioVorbis() : MDAudioFile()
 {}
 
@@ -289,6 +323,8 @@ bool MDAudioVorbis::close()
         if(m_file)
         {
             vorbis_analysis_wrote(&m_vd, 0);
+            writeFlush();
+
             ogg_stream_clear(&m_os);
             vorbis_block_clear(&m_vb);
             vorbis_dsp_clear(&m_vd);
@@ -321,10 +357,11 @@ size_t MDAudioVorbis::readChunk(uint8_t *out, size_t outSize, bool *spec_changed
 #else
     amount = (int)ov_read(&m_vf, (char*)out, outSize, SDL_BYTEORDER == SDL_BIG_ENDIAN, 2, 1, &cur_section);
 #endif
-    if (amount < 0)
+
+    if(amount < 0)
     {
         set_ov_error("ov_read", amount);
-        return 0;
+        return ~(size_t)0;
     }
 
     if(cur_section != m_section)
@@ -344,7 +381,7 @@ size_t MDAudioVorbis::readChunk(uint8_t *out, size_t outSize, bool *spec_changed
 size_t MDAudioVorbis::writeChunk(uint8_t *in, size_t inSize)
 {
     long i;
-    int eos = 0;
+    size_t written = 0;
     int sample_size = m_spec.m_channels * sizeof(short);
     /* expose the buffer to submit data */
 
@@ -359,36 +396,10 @@ size_t MDAudioVorbis::writeChunk(uint8_t *in, size_t inSize)
             buffer[c][i] = *(in_s++) / 32768.f;
     }
 
+    written += i * sample_size;
     vorbis_analysis_wrote(&m_vd, i);
 
-    while(vorbis_analysis_blockout(&m_vd, &m_vb) == 1)
-    {
-        /* analysis, assume we want to use bitrate management */
-        vorbis_analysis(&m_vb, nullptr);
-        vorbis_bitrate_addblock(&m_vb);
-
-        while(vorbis_bitrate_flushpacket(&m_vd, &m_op))
-        {
-            /* weld the packet into the bitstream */
-            ogg_stream_packetin(&m_os, &m_op);
-
-            /* write out pages (if any) */
-            while(!eos)
-            {
-                int result = ogg_stream_pageout(&m_os, &m_og);
-                if(result == 0)
-                    break;
-
-                SDL_RWwrite(m_file, m_og.header, 1, m_og.header_len);
-                SDL_RWwrite(m_file, m_og.body, 1, m_og.body_len);
-
-                /* this could be set above, but for illustrative purposes, I do
-                   it here (to show that vorbis does know where the stream ends) */
-                if(ogg_page_eos(&m_og))
-                    eos = 1;
-            }
-        }
-    }
+    writeFlush();
 
-    return 0;
+    return written;
 }