react-native-audio-api 0.9.0-nightly-96a5bcd-20251007 → 0.9.0

package/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.cpp

@@ -1,20 +1,16 @@
 /*
- * This file dynamically links to the FFmpeg library, which is licensed under
- * the GNU Lesser General Public License (LGPL) version 2.1 or later.
+ * This file dynamically links to the FFmpeg library, which is licensed under the
+ * GNU Lesser General Public License (LGPL) version 2.1 or later.
  *
- * Our own code in this file is licensed under the MIT License and dynamic
- * linking allows you to use this code without your entire project being subject
- * to the terms of the LGPL. However, note that if you link statically to
- * FFmpeg, you must comply with the terms of the LGPL for FFmpeg itself.
+ * Our own code in this file is licensed under the MIT License and dynamic linking
+ * allows you to use this code without your entire project being subject to the
+ * terms of the LGPL. However, note that if you link statically to FFmpeg, you must
+ * comply with the terms of the LGPL for FFmpeg itself.
  */
 
-#include <audioapi/core/sources/AudioBuffer.h>
-#include <audioapi/libs/ffmpeg/FFmpegDecoding.h>
-#include <audioapi/utils/AudioArray.h>
-#include <audioapi/utils/AudioBus.h>
-#include <functional>
+#include "FFmpegDecoding.h"
 
-namespace audioapi::ffmpegdecoder {
+namespace audioapi::ffmpegdecoding {
 
 int read_packet(void *opaque, uint8_t *buf, int buf_size) {
   MemoryIOContext *ctx = static_cast<MemoryIOContext *>(opaque);
@@ -55,87 +51,42 @@ int64_t seek_packet(void *opaque, int64_t offset, int whence) {
   return ctx->pos;
 }
 
-void convertFrameToBuffer(
-    SwrContext *swr,
-    AVFrame *frame,
-    int output_channel_count,
-    std::vector<float> &buffer,
-    size_t &framesRead,
-    uint8_t **&resampled_data,
-    int &max_resampled_samples) {
-  const int out_samples = swr_get_out_samples(swr, frame->nb_samples);
-  if (out_samples > max_resampled_samples) {
-    av_freep(&resampled_data[0]);
-    av_freep(&resampled_data);
-    max_resampled_samples = out_samples;
-
-    if (av_samples_alloc_array_and_samples(
-            &resampled_data,
-            nullptr,
-            output_channel_count,
-            max_resampled_samples,
-            AV_SAMPLE_FMT_FLT,
-            0) < 0) {
-      return;
-    }
-  }
-
-  int converted_samples = swr_convert(
-      swr,
-      resampled_data,
-      max_resampled_samples,
-      const_cast<const uint8_t **>(frame->data),
-      frame->nb_samples);
-
-  if (converted_samples > 0) {
-    const size_t current_size = buffer.size();
-    const size_t new_samples =
-        static_cast<size_t>(converted_samples) * output_channel_count;
-    buffer.resize(current_size + new_samples);
-    memcpy(
-        buffer.data() + current_size,
-        resampled_data[0],
-        new_samples * sizeof(float));
-    framesRead += converted_samples;
-  }
-}
-
-std::vector<float> readAllPcmFrames(
+std::vector<int16_t> readAllPcmFrames(
     AVFormatContext *fmt_ctx,
     AVCodecContext *codec_ctx,
     int out_sample_rate,
-    int output_channel_count,
     int audio_stream_index,
+    int channels,
     size_t &framesRead) {
-  framesRead = 0;
-  std::vector<float> buffer;
-  auto swr = std::unique_ptr<SwrContext, std::function<void(SwrContext *)>>(
-      swr_alloc(), [](SwrContext *ctx) { swr_free(&ctx); });
-
-  if (swr == nullptr)
+  std::vector<int16_t> buffer;
+  SwrContext *swr_ctx = swr_alloc();
+  if (swr_ctx == nullptr) {
     return buffer;
+  }
 
-  av_opt_set_chlayout(swr.get(), "in_chlayout", &codec_ctx->ch_layout, 0);
-  av_opt_set_int(swr.get(), "in_sample_rate", codec_ctx->sample_rate, 0);
-  av_opt_set_sample_fmt(swr.get(), "in_sample_fmt", codec_ctx->sample_fmt, 0);
+  av_opt_set_chlayout(swr_ctx, "in_chlayout", &codec_ctx->ch_layout, 0);
+  av_opt_set_int(swr_ctx, "in_sample_rate", codec_ctx->sample_rate, 0);
+  av_opt_set_sample_fmt(swr_ctx, "in_sample_fmt", codec_ctx->sample_fmt, 0);
 
   AVChannelLayout out_ch_layout;
-  av_channel_layout_default(&out_ch_layout, output_channel_count);
-  av_opt_set_chlayout(swr.get(), "out_chlayout", &out_ch_layout, 0);
-  av_opt_set_int(swr.get(), "out_sample_rate", out_sample_rate, 0);
-  av_opt_set_sample_fmt(swr.get(), "out_sample_fmt", AV_SAMPLE_FMT_FLT, 0);
+  av_channel_layout_default(&out_ch_layout, channels);
+  av_opt_set_chlayout(swr_ctx, "out_chlayout", &out_ch_layout, 0);
+  av_opt_set_int(swr_ctx, "out_sample_rate", out_sample_rate, 0);
+  av_opt_set_sample_fmt(swr_ctx, "out_sample_fmt", AV_SAMPLE_FMT_S16, 0);
 
-  if (swr_init(swr.get()) < 0) {
+  if (swr_init(swr_ctx) < 0) {
+    swr_free(&swr_ctx);
     av_channel_layout_uninit(&out_ch_layout);
     return buffer;
   }
 
-  auto packet = std::unique_ptr<AVPacket, std::function<void(AVPacket *)>>(
-      av_packet_alloc(), [](AVPacket *p) { av_packet_free(&p); });
-  auto frame = std::unique_ptr<AVFrame, std::function<void(AVFrame *)>>(
-      av_frame_alloc(), [](AVFrame *p) { av_frame_free(&p); });
-
+  AVPacket *packet = av_packet_alloc();
+  AVFrame *frame = av_frame_alloc();
+  
   if (packet == nullptr || frame == nullptr) {
+    if (packet != nullptr) av_packet_free(&packet);
+    if (frame != nullptr) av_frame_free(&frame);
+    swr_free(&swr_ctx);
     av_channel_layout_uninit(&out_ch_layout);
     return buffer;
   }
@@ -143,222 +94,312 @@ std::vector<float> readAllPcmFrames(
   // Allocate buffer for resampled data
   uint8_t **resampled_data = nullptr;
   int max_resampled_samples = 4096; // Initial size
-  if (av_samples_alloc_array_and_samples(
-          &resampled_data,
-          nullptr,
-          output_channel_count,
-          max_resampled_samples,
-          AV_SAMPLE_FMT_FLT,
-          0) < 0) {
+  int ret = av_samples_alloc_array_and_samples(
+      &resampled_data,
+      nullptr,
+      channels,
+      max_resampled_samples,
+      AV_SAMPLE_FMT_S16,
+      0);
+
+  if (ret < 0) {
+    av_frame_free(&frame);
+    av_packet_free(&packet);
+    swr_free(&swr_ctx);
     av_channel_layout_uninit(&out_ch_layout);
     return buffer;
   }
 
-  while (av_read_frame(fmt_ctx, packet.get()) >= 0) {
+  framesRead = 0;
+
+  while (av_read_frame(fmt_ctx, packet) >= 0) {
     if (packet->stream_index == audio_stream_index) {
-      if (avcodec_send_packet(codec_ctx, packet.get()) == 0) {
-        while (avcodec_receive_frame(codec_ctx, frame.get()) == 0) {
-          convertFrameToBuffer(
-              swr.get(),
-              frame.get(),
-              output_channel_count,
-              buffer,
-              framesRead,
+      if (avcodec_send_packet(codec_ctx, packet) == 0) {
+        while (avcodec_receive_frame(codec_ctx, frame) == 0) {
+          // Check if we need more buffer space
+          int out_samples = swr_get_out_samples(swr_ctx, frame->nb_samples);
+          if (out_samples > max_resampled_samples) {
+            if (resampled_data != nullptr) {
+              av_freep(&resampled_data[0]);
+              av_freep(&resampled_data);
+            }
+
+            max_resampled_samples = out_samples;
+            ret = av_samples_alloc_array_and_samples(
+                &resampled_data,
+                nullptr,
+                channels,
+                max_resampled_samples,
+                AV_SAMPLE_FMT_S16,
+                0);
+            
+            if (ret < 0) {
+              break; // Exit on allocation failure
+            }
+          }
+
+          int converted_samples = swr_convert(
+              swr_ctx,
               resampled_data,
-              max_resampled_samples);
+              max_resampled_samples,
+              (const uint8_t **)frame->data,
+              frame->nb_samples);
+
+          if (converted_samples > 0) {
+            size_t current_size = buffer.size();
+            size_t new_samples = converted_samples * channels;
+            buffer.resize(current_size + new_samples);
+            memcpy(
+                buffer.data() + current_size,
+                resampled_data[0],
+                new_samples * sizeof(int16_t));
+            
+            framesRead += converted_samples;
+          }
         }
       }
     }
-    av_packet_unref(packet.get());
+    av_packet_unref(packet);
   }
 
   // Flush decoder
   avcodec_send_packet(codec_ctx, nullptr);
-  while (avcodec_receive_frame(codec_ctx, frame.get()) == 0) {
-    convertFrameToBuffer(
-        swr.get(),
-        frame.get(),
-        output_channel_count,
-        buffer,
-        framesRead,
+  while (avcodec_receive_frame(codec_ctx, frame) == 0) {
+    int out_samples = swr_get_out_samples(swr_ctx, frame->nb_samples);
+    if (out_samples > max_resampled_samples) {
+      if (resampled_data != nullptr) {
+        av_freep(&resampled_data[0]);
+        av_freep(&resampled_data);
+      }
+
+      max_resampled_samples = out_samples;
+      ret = av_samples_alloc_array_and_samples(
+          &resampled_data,
+          nullptr,
+          channels,
+          max_resampled_samples,
+          AV_SAMPLE_FMT_S16,
+          0);
+      
+      if (ret < 0) {
+        break;
+      }
+    }
+
+    int converted_samples = swr_convert(
+        swr_ctx,
         resampled_data,
-        max_resampled_samples);
+        max_resampled_samples,
+        (const uint8_t **)frame->data,
+        frame->nb_samples);
+
+    if (converted_samples > 0) {
+      size_t current_size = buffer.size();
+      size_t new_samples = converted_samples * channels;
+      buffer.resize(current_size + new_samples);
+      memcpy(
+          buffer.data() + current_size,
+          resampled_data[0],
+          new_samples * sizeof(int16_t));
+      
+      framesRead += converted_samples;
+    }
   }
 
-  av_freep(&resampled_data[0]);
-  av_freep(&resampled_data);
+  if (resampled_data != nullptr) {
+    av_freep(&resampled_data[0]);
+    av_freep(&resampled_data);
+  }
+  swr_free(&swr_ctx);
   av_channel_layout_uninit(&out_ch_layout);
+  av_frame_free(&frame);
+  av_packet_free(&packet);
 
   return buffer;
 }
 
-inline int findAudioStreamIndex(AVFormatContext *fmt_ctx) {
-  for (int i = 0; i < fmt_ctx->nb_streams; i++) {
-    if (fmt_ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
-      return i;
+std::vector<int16_t> decodeWithMemoryBlock(const void *data, size_t size, const int channel_count, int sample_rate) {
+    if (data == nullptr || size == 0) {
+        return {};
     }
-  }
-  return -1;
-}
 
-bool setupDecoderContext(
-    AVFormatContext *fmt_ctx,
-    int &audio_stream_index,
-    std::unique_ptr<AVCodecContext, std::function<void(AVCodecContext *)>>
-        &codec_ctx) {
-  audio_stream_index = findAudioStreamIndex(fmt_ctx);
-  if (audio_stream_index == -1) {
-    return false;
-  }
+    MemoryIOContext io_ctx;
+    io_ctx.data = static_cast<const uint8_t *>(data);
+    io_ctx.size = size;
+    io_ctx.pos = 0;
 
-  AVCodecParameters *codecpar = fmt_ctx->streams[audio_stream_index]->codecpar;
-  const AVCodec *codec = avcodec_find_decoder(codecpar->codec_id);
-  if (codec == nullptr) {
-    return false;
-  }
+    constexpr size_t buffer_size = 4096;
+    uint8_t *io_buffer = static_cast<uint8_t *>(av_malloc(buffer_size));
+    if (io_buffer == nullptr) {
+        return {};
+    }
 
-  AVCodecContext *raw_codec_ctx = avcodec_alloc_context3(codec);
-  if (raw_codec_ctx == nullptr) {
-    return false;
-  }
+    AVIOContext *avio_ctx = avio_alloc_context(
+        io_buffer, buffer_size, 0, &io_ctx, read_packet, nullptr, seek_packet);
 
-  codec_ctx.reset(raw_codec_ctx);
-  if (avcodec_parameters_to_context(codec_ctx.get(), codecpar) < 0) {
-    return false;
-  }
-  if (avcodec_open2(codec_ctx.get(), codec, nullptr) < 0) {
-    return false;
-  }
+    if (avio_ctx == nullptr) {
+      av_free(io_buffer);
+      return {};
+    }
 
-  return true;
-}
+    // Create format context and set custom IO
+    AVFormatContext *fmt_ctx = avformat_alloc_context();
+    if (fmt_ctx == nullptr) {
+      avio_context_free(&avio_ctx);
+      return {};
+    }
+    
+    fmt_ctx->pb = avio_ctx;
+
+    // Open input from memory
+    if (avformat_open_input(&fmt_ctx, nullptr, nullptr, nullptr) < 0) {
+      avformat_free_context(fmt_ctx);
+      avio_context_free(&avio_ctx);
+      return {};
+    }
 
-std::shared_ptr<AudioBuffer> decodeAudioFrames(
-    AVFormatContext *fmt_ctx,
-    AVCodecContext *codec_ctx,
-    int audio_stream_index,
-    int sample_rate) {
-  size_t framesRead = 0;
-  int output_sample_rate =
-      (sample_rate > 0) ? sample_rate : codec_ctx->sample_rate;
-  int output_channel_count = codec_ctx->ch_layout.nb_channels;
-
-  std::vector<float> decoded_buffer = readAllPcmFrames(
-      fmt_ctx,
-      codec_ctx,
-      output_sample_rate,
-      output_channel_count,
-      audio_stream_index,
-      framesRead);
+    // Find stream info
+    if (avformat_find_stream_info(fmt_ctx, nullptr) < 0) {
+      avformat_close_input(&fmt_ctx);
+      avio_context_free(&avio_ctx);
+      return {};
+    }
 
-  if (framesRead == 0 || decoded_buffer.empty()) {
-    return nullptr;
-  }
+    int audio_stream_index = -1;
+    for (int i = 0; i < fmt_ctx->nb_streams; i++) {
+      if (fmt_ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
+        audio_stream_index = i;
+        break;
+      }
+    }
+
+    if (audio_stream_index == -1) {
+      avformat_close_input(&fmt_ctx);
+      avio_context_free(&avio_ctx);
+      return {};
+    }
 
-  auto outputFrames = decoded_buffer.size() / output_channel_count;
-  auto audioBus = std::make_shared<AudioBus>(
-      outputFrames, output_channel_count, output_sample_rate);
+    AVCodecParameters *codecpar = fmt_ctx->streams[audio_stream_index]->codecpar;
 
-  for (int ch = 0; ch < output_channel_count; ++ch) {
-    auto channelData = audioBus->getChannel(ch)->getData();
-    for (int i = 0; i < outputFrames; ++i) {
-      channelData[i] = decoded_buffer[i * output_channel_count + ch];
+    // Find decoder
+    const AVCodec *codec = avcodec_find_decoder(codecpar->codec_id);
+    if (codec == nullptr) {
+      avformat_close_input(&fmt_ctx);
+      avio_context_free(&avio_ctx);
+      return {};
     }
-  }
-  return std::make_shared<AudioBuffer>(audioBus);
-}
 
-std::shared_ptr<AudioBuffer>
-decodeWithMemoryBlock(const void *data, size_t size, int sample_rate) {
-  if (data == nullptr || size == 0) {
-    return nullptr;
-  }
+    // Allocate and setup codec context
+    AVCodecContext *codec_ctx = avcodec_alloc_context3(codec);
+    if (codec_ctx == nullptr) {
+      avformat_close_input(&fmt_ctx);
+      avio_context_free(&avio_ctx);
+      return {};
+    }
 
-  MemoryIOContext io_ctx{static_cast<const uint8_t *>(data), size, 0};
+    if (avcodec_parameters_to_context(codec_ctx, codecpar) < 0) {
+      avcodec_free_context(&codec_ctx);
+      avformat_close_input(&fmt_ctx);
+      avio_context_free(&avio_ctx);
+      return {};
+    }
 
-  constexpr size_t buffer_size = 4096;
-  auto io_buffer = std::unique_ptr<uint8_t, decltype(&av_free)>(
-      static_cast<uint8_t *>(av_malloc(buffer_size)), &av_free);
-  if (io_buffer == nullptr) {
-    return nullptr;
-  }
+    if (avcodec_open2(codec_ctx, codec, nullptr) < 0) {
+      avcodec_free_context(&codec_ctx);
+      avformat_close_input(&fmt_ctx);
+      avio_context_free(&avio_ctx);
+      return {};
+    }
 
-  auto avio_ctx =
-      std::unique_ptr<AVIOContext, std::function<void(AVIOContext *)>>(
-          avio_alloc_context(
-              io_buffer.get(),
-              buffer_size,
-              0,
-              &io_ctx,
-              read_packet,
-              nullptr,
-              seek_packet),
-          [](AVIOContext *ctx) { avio_context_free(&ctx); });
-  if (avio_ctx == nullptr) {
-    return nullptr;
-  }
+    // Get actual channel count from the decoded stream
+    int actual_channels = codec_ctx->ch_layout.nb_channels;
 
-  AVFormatContext *raw_fmt_ctx = avformat_alloc_context();
-  if (raw_fmt_ctx == nullptr) {
-    return nullptr;
-  }
-  raw_fmt_ctx->pb = avio_ctx.get();
+    // Validate channel count
+    if (actual_channels <= 0 || actual_channels > 8) {
+      avcodec_free_context(&codec_ctx);
+      avformat_close_input(&fmt_ctx);
+      avio_context_free(&avio_ctx);
+      return {};
+    }
 
-  if (avformat_open_input(&raw_fmt_ctx, nullptr, nullptr, nullptr) < 0) {
-    avformat_free_context(raw_fmt_ctx);
-    return nullptr;
-  }
+    // Decode all frames
+    size_t framesRead = 0;
+    std::vector<int16_t> decoded_buffer = readAllPcmFrames(
+        fmt_ctx, codec_ctx, sample_rate, audio_stream_index, channel_count, framesRead);
 
-  auto fmt_ctx =
-      std::unique_ptr<AVFormatContext, decltype(&avformat_free_context)>(
-          raw_fmt_ctx, &avformat_free_context);
+    // Cleanup - Note: avio_context_free will free the io_buffer
+    avcodec_free_context(&codec_ctx);
+    avformat_close_input(&fmt_ctx);
+    avio_context_free(&avio_ctx);
 
-  if (avformat_find_stream_info(fmt_ctx.get(), nullptr) < 0) {
-    return nullptr;
+    if (framesRead == 0 || decoded_buffer.empty()) {
+      return {};
+    }
+
+    return decoded_buffer;
+}
+
+std::vector<int16_t> decodeWithFilePath(const std::string &path, const int channel_count, int sample_rate) {
+  if (path.empty()) {
+      return {};
   }
 
-  auto codec_ctx =
-      std::unique_ptr<AVCodecContext, std::function<void(AVCodecContext *)>>(
-          nullptr, [](AVCodecContext *ctx) { avcodec_free_context(&ctx); });
+  AVFormatContext *fmt_ctx = nullptr;
+  if (avformat_open_input(&fmt_ctx, path.c_str(), nullptr, nullptr) < 0) {
+      return {};
+  }
+  if (avformat_find_stream_info(fmt_ctx, nullptr) < 0) {
+      avformat_close_input(&fmt_ctx);
+      return {};
+  }
   int audio_stream_index = -1;
-  if (!setupDecoderContext(fmt_ctx.get(), audio_stream_index, codec_ctx)) {
-    return nullptr;
+  for (int i = 0; i < fmt_ctx->nb_streams; i++) {
+      if (fmt_ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
+          audio_stream_index = i;
+          break;
+      }
+  }
+  if (audio_stream_index == -1) {
+      avformat_close_input(&fmt_ctx);
+      return {};
   }
 
-  return decodeAudioFrames(
-      fmt_ctx.get(), codec_ctx.get(), audio_stream_index, sample_rate);
-}
+  AVCodecParameters *codecpar = fmt_ctx->streams[audio_stream_index]->codecpar;
+  const AVCodec *codec = avcodec_find_decoder(codecpar->codec_id);
+  if (codec == nullptr) {
+      avformat_close_input(&fmt_ctx);
+      return {};
+  }
+  AVCodecContext *codec_ctx = avcodec_alloc_context3(codec);
+  if (codec_ctx == nullptr) {
+      avformat_close_input(&fmt_ctx);
+      return {};
+  }
 
-std::shared_ptr<AudioBuffer> decodeWithFilePath(
-    const std::string &path,
-    int sample_rate) {
-  if (path.empty()) {
-    return nullptr;
+  if (avcodec_parameters_to_context(codec_ctx, codecpar) < 0) {
+      avcodec_free_context(&codec_ctx);
+      avformat_close_input(&fmt_ctx);
+      return {};
   }
 
-  AVFormatContext *raw_fmt_ctx = nullptr;
-  if (avformat_open_input(&raw_fmt_ctx, path.c_str(), nullptr, nullptr) < 0)
-    return nullptr;
+  if (avcodec_open2(codec_ctx, codec, nullptr) < 0) {
+      avcodec_free_context(&codec_ctx);
+      avformat_close_input(&fmt_ctx);
+      return {};
+  }
 
-  auto fmt_ctx =
-      std::unique_ptr<AVFormatContext, std::function<void(AVFormatContext *)>>(
-          raw_fmt_ctx,
-          [](AVFormatContext *ctx) { avformat_close_input(&ctx); });
+  size_t framesRead = 0;
+  std::vector<int16_t> decoded_buffer = readAllPcmFrames(
+      fmt_ctx, codec_ctx, sample_rate, audio_stream_index, channel_count, framesRead);
 
-  if (avformat_find_stream_info(fmt_ctx.get(), nullptr) < 0) {
-    return nullptr;
-  }
+  avcodec_free_context(&codec_ctx);
+  avformat_close_input(&fmt_ctx);
 
-  auto codec_ctx =
-      std::unique_ptr<AVCodecContext, std::function<void(AVCodecContext *)>>(
-          nullptr, [](AVCodecContext *ctx) { avcodec_free_context(&ctx); });
-  int audio_stream_index = -1;
-  if (!setupDecoderContext(fmt_ctx.get(), audio_stream_index, codec_ctx)) {
-    return nullptr;
+  if (framesRead == 0 || decoded_buffer.empty()) {
+      return {};
   }
 
-  return decodeAudioFrames(
-      fmt_ctx.get(), codec_ctx.get(), audio_stream_index, sample_rate);
+  return decoded_buffer;
 }
 
 } // namespace audioapi::ffmpegdecoder