Merge pull request #522 from ShFil119/prepare_sdt_loader_for_ffmpeg

Prepare sdt loader for ffmpeg

Author: danhedron

rwengine/src/audio/SoundManager.cpp

@@ -1,10 +1,11 @@
-#include "audio/SoundManager.hpp"
-
 #include "audio/alCheck.hpp"
+#include "audio/SoundManager.hpp"
+#include "loaders/LoaderSDT.hpp"
 
 extern "C" {
 #include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
+#include <libavformat/avio.h>
 #include <libavutil/avutil.h>
 }
 //ab
@@ -16,6 +17,10 @@ extern "C" {
 #define av_frame_free   avcodec_free_frame
 #endif
 
+#if LIBAVFORMAT_VERSION_INT < AV_VERSION_INT(57,80,100)
+#define avio_context_free av_freep
+#endif
+
 SoundManager::SoundManager() {
     initializeOpenAL();
     initializeAVCodec();
@@ -173,6 +178,243 @@ void SoundManager::SoundSource::loadFromFile(const rwfs::path& filePath) {
     avformat_close_input(&formatContext);
 }
 
+/// Structure for input data
+struct InputData {
+    uint8_t *ptr = nullptr;
+    size_t size{}; ///< size left in the buffer
+};
+
+/// Low level function for copying data from handler (opaque)
+/// to buffer.
+static int read_packet(void *opaque, uint8_t *buf, int buf_size) {
+    auto* input = reinterpret_cast<InputData*>(opaque);
+    buf_size = FFMIN(buf_size, input->size);
+    /* copy internal data to buf */
+    memcpy(buf, input->ptr, buf_size);
+    input->ptr  += buf_size;
+    input->size -= buf_size;
+    return buf_size;
+}
+
+void SoundManager::SoundSource::loadSfx(const rwfs::path& path, const size_t& index, const bool asWave) {
+    // Allocate audio frame
+    AVFrame* frame = av_frame_alloc();
+    if (!frame) {
+        RW_ERROR("Error allocating the audio frame");
+        return;
+    }
+
+    /// Now we need to prepare "custom" format context
+    /// We need sdt loader for that purpose
+    LoaderSDT sdt{};
+    sdt.load(path / "audio/sfx");
+
+    std::unique_ptr<char[]> raw_sound = sdt.loadToMemory(index, asWave);
+    if (!raw_sound) {
+        av_frame_free(&frame);
+        RW_ERROR("Error loading sound");
+        return;
+    }
+
+    /// Prepare input
+    InputData input{};
+    input.size = sizeof(WaveHeader) + sdt.assetInfo.size;
+    auto inputDataStart = std::make_unique<uint8_t[]>(input.size); /// Store start ptr of data to be able freed memory later
+    input.ptr = inputDataStart.get();
+
+    /// Alocate memory for buffer
+    /// Memory freeded at the end
+    static constexpr size_t ioBufferSize = 4096;
+    auto  ioBuffer = static_cast<uint8_t*>(av_malloc(ioBufferSize));
+
+    /// Cast pointer, in order to match required layout for ffmpeg
+    input.ptr = reinterpret_cast<uint8_t*>(raw_sound.get());
+
+    /// Finally prepare our "custom" format context
+    AVIOContext* avioContext = avio_alloc_context(ioBuffer, ioBufferSize, 0, &input, &read_packet, nullptr, nullptr);
+    AVFormatContext* formatContext = avformat_alloc_context();
+    formatContext->pb = avioContext;
+
+    if (avformat_open_input(&formatContext, "nothint", nullptr, nullptr) != 0) {
+        av_free(formatContext->pb->buffer);
+        avio_context_free(&formatContext->pb);
+        av_frame_free(&frame);
+        RW_ERROR("Error opening audio file (" << index << ")");
+        return;
+    }
+
+    if (avformat_find_stream_info(formatContext, nullptr) < 0) {
+        av_free(formatContext->pb->buffer);
+        avio_context_free(&formatContext->pb);
+        av_frame_free(&frame);
+        avformat_close_input(&formatContext);
+        RW_ERROR("Error finding audio stream info");
+        return;
+    }
+
+    // Find the audio stream
+    //AVCodec* codec = nullptr;
+    int streamIndex = av_find_best_stream(formatContext, AVMEDIA_TYPE_AUDIO, -1, -1, nullptr, 0);
+    if (streamIndex < 0) {
+        av_free(formatContext->pb->buffer);
+        avio_context_free(&formatContext->pb);
+        av_frame_free(&frame);
+        avformat_close_input(&formatContext);
+        RW_ERROR("Could not find any audio stream in the file ");
+        return;
+    }
+
+    AVStream* audioStream = formatContext->streams[streamIndex];
+    AVCodec* codec = avcodec_find_decoder(audioStream->codecpar->codec_id);
+
+#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(57,5,0)
+    AVCodecContext* codecContext = audioStream->codec;
+    codecContext->codec = codec;
+
+    // Open the codec
+    if (avcodec_open2(codecContext, codecContext->codec, nullptr) != 0) {
+        av_free(formatContext->pb->buffer);
+        avio_context_free(&formatContext->pb);
+        av_frame_free(&frame);
+        avformat_close_input(&formatContext);
+        RW_ERROR("Couldn't open the audio codec context");
+        return;
+    }
+#else
+    // Initialize codec context for the decoder.
+    AVCodecContext* codecContext = avcodec_alloc_context3(codec);
+    if (!codecContext) {
+        av_free(formatContext->pb->buffer);
+        avio_context_free(&formatContext->pb);
+        av_frame_free(&frame);
+        avformat_close_input(&formatContext);
+        RW_ERROR("Couldn't allocate a decoding context.");
+        return;
+    }
+
+    // Fill the codecCtx with the parameters of the codec used in the read file.
+    if (avcodec_parameters_to_context(codecContext, audioStream->codecpar) != 0) {
+        av_free(formatContext->pb->buffer);
+        avio_context_free(&formatContext->pb);
+        avcodec_close(codecContext);
+        avcodec_free_context(&codecContext);
+        avformat_close_input(&formatContext);
+        RW_ERROR("Couldn't find parametrs for context");
+        return;
+    }
+
+    // Initialize the decoder.
+    if (avcodec_open2(codecContext, codec, nullptr) != 0) {
+        av_free(formatContext->pb->buffer);
+        avio_context_free(&formatContext->pb);
+        avcodec_close(codecContext);
+        avcodec_free_context(&codecContext);
+        avformat_close_input(&formatContext);
+        RW_ERROR("Couldn't open the audio codec context");
+        return;
+    }
+#endif
+
+    // Expose audio metadata
+    channels = static_cast<size_t>(codecContext->channels);
+    sampleRate = sdt.assetInfo.sampleRate;
+
+    // OpenAL only supports mono or stereo, so error on more than 2 channels
+    if(channels > 2) {
+        RW_ERROR("Audio has more than two channels");
+        av_free(formatContext->pb->buffer);
+        avio_context_free(&formatContext->pb);
+        av_frame_free(&frame);
+        avcodec_close(codecContext);
+        avformat_close_input(&formatContext);
+        return;
+    }
+
+    // Start reading audio packets
+    AVPacket readingPacket;
+    av_init_packet(&readingPacket);
+
+#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(57,37,100)
+
+    while (av_read_frame(formatContext, &readingPacket) == 0) {
+        if (readingPacket.stream_index == audioStream->index) {
+            AVPacket decodingPacket = readingPacket;
+
+            while (decodingPacket.size > 0) {
+                // Decode audio packet
+                int gotFrame = 0;
+                int len = avcodec_decode_audio4(codecContext, frame, &gotFrame, &decodingPacket);
+
+                if (len >= 0 && gotFrame) {
+                    // Write samples to audio buffer
+
+                    for(size_t i = 0; i < static_cast<size_t>(frame->nb_samples); i++) {
+                        // Interleave left/right channels
+                        for(size_t channel = 0; channel < channels; channel++) {
+                            int16_t sample = reinterpret_cast<int16_t *>(frame->data[channel])[i];
+                            data.push_back(sample);
+                        }
+                    }
+
+                    decodingPacket.size -= len;
+                    decodingPacket.data += len;
+                }
+                else {
+                    decodingPacket.size = 0;
+                    decodingPacket.data = nullptr;
+                }
+            }
+        }
+        av_free_packet(&readingPacket);
+    }
+#else
+
+    while (av_read_frame(formatContext, &readingPacket) == 0) {
+        if (readingPacket.stream_index == audioStream->index) {
+            AVPacket decodingPacket = readingPacket;
+
+            int sendPacket = avcodec_send_packet(codecContext, &decodingPacket);
+            int receiveFrame = 0;
+
+            while ((receiveFrame = avcodec_receive_frame(codecContext, frame)) == 0) {
+                // Decode audio packet
+
+                if (receiveFrame == 0 && sendPacket == 0) {
+                    // Write samples to audio buffer
+
+                    for(size_t i = 0; i < static_cast<size_t>(frame->nb_samples); i++) {
+                        // Interleave left/right channels
+                        for(size_t channel = 0; channel < channels; channel++) {
+                            int16_t sample = reinterpret_cast<int16_t *>(frame->data[channel])[i];
+                            data.push_back(sample);
+                        }
+                    }
+                }
+            }
+        }
+        av_packet_unref(&readingPacket);
+    }
+
+#endif
+
+    // Cleanup
+    /// Free all data used by the frame.
+    av_frame_free(&frame);
+
+    /// Close the context and free all data associated to it, but not the context itself.
+    avcodec_close(codecContext);
+
+    /// Free the context itself.
+    avcodec_free_context(&codecContext);
+
+    /// Free our custom AVIO.
+    av_free(formatContext->pb->buffer);
+    avio_context_free(&formatContext->pb);
+
+    /// We are done here. Close the input.
+    avformat_close_input(&formatContext);
+}
+
 SoundManager::SoundBuffer::SoundBuffer() {
     alCheck(alGenSources(1, &source));
     alCheck(alGenBuffers(1, &buffer));

rwengine/src/audio/SoundManager.hpp

@@ -12,6 +12,8 @@
 #include <al.h>
 #include <alc.h>
 
+#include <rw/filesystem.hpp>
+
 class SoundManager {
 public:
     SoundManager();
@@ -43,6 +45,7 @@ class SoundManager {
 
     public:
         void loadFromFile(const rwfs::path& filePath);
+        void loadSfx(const rwfs::path& path, const size_t& index, const bool asWave = true);
 
     private:
         std::vector<int16_t> data;