react-native-audio-api 0.11.0-alpha.1 → 0.11.0-alpha.2

package/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/FFmpegFileWriter.h

@@ -1,113 +1,70 @@
 #pragma once
 
-extern "C" {
-#include <libavutil/opt.h>
-#include <libavcodec/avcodec.h>
-#include <libavutil/audio_fifo.h>
-#include <libavformat/avformat.h>
-#include <libswresample/swresample.h>
-#include <libavutil/channel_layout.h>
-}
-
 #include <audioapi/android/core/utils/AndroidFileWriterBackend.h>
-
+#include <audioapi/android/core/utils/ffmpegBackend/utils.h>
 #include <string>
 #include <memory>
 #include <tuple>
+#include <chrono>
+#include <audioapi/utils/Result.hpp>
 
-namespace audioapi {
-
-class FFmpegAudioFileOptions;
-
-struct AVCodecContextDTOR {
-  void operator()(AVCodecContext* ctx) const {
-    if (ctx) {
-      avcodec_free_context(&ctx);
-    }
-  }
-};
-
-struct AVFormatContextDTOR {
-  void operator()(AVFormatContext* ctx) const {
-    if (ctx) {
-      avformat_free_context(ctx);
-    }
-  }
-};
-
-struct AVFrameDTOR {
-  void operator()(AVFrame* frame) const {
-    if (frame) {
-      av_frame_free(&frame);
-    }
-  }
-};
-
-struct AVPacketDTOR {
-  void operator()(AVPacket* packet) const {
-    if (packet) {
-      av_packet_free(&packet);
-    }
-  }
-};
+struct AVCodecContext;
+struct AVFormatContext;
+struct AVFrame;
+struct AVPacket;
+struct AVAudioFifo;
+struct SwrContext;
+struct AVStream;
 
-struct SwrContextDTOR {
-  void operator()(SwrContext* ctx) const {
-    if (ctx) {
-      swr_free(&ctx);
-    }
-  }
-};
+namespace audioapi {
 
-struct AVAudioFifoDTOR {
-  void operator()(AVAudioFifo* fifo) const {
-    if (fifo) {
-      av_audio_fifo_free(fifo);
-    }
-  }
-};
+class AudioFileProperties;
 
-using AVCodecContextPtr = std::unique_ptr<AVCodecContext, AVCodecContextDTOR>;
-using AVFormatContextPtr = std::unique_ptr<AVFormatContext, AVFormatContextDTOR>;
-using AVFramePtr = std::unique_ptr<AVFrame, AVFrameDTOR>;
-using AVPacketPtr = std::unique_ptr<AVPacket, AVPacketDTOR>;
-using SwrContextPtr = std::unique_ptr<SwrContext, SwrContextDTOR>;
-using AVAudioFifoPtr = std::unique_ptr<AVAudioFifo, AVAudioFifoDTOR>;
+namespace android::ffmpeg {
 
 class FFmpegAudioFileWriter : public AndroidFileWriterBackend {
  public:
-  FFmpegAudioFileWriter(
-    float sampleRate,
-    size_t channelCount,
-    size_t bitRate,
-    size_t androidFlags);
-  ~FFmpegAudioFileWriter() override;
+  explicit FFmpegAudioFileWriter(
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+      const std::shared_ptr<AudioFileProperties> &fileProperties);
+  ~FFmpegAudioFileWriter();
 
-  std::string openFile(int32_t streamSampleRate, int32_t streamChannelCount, int32_t streamMaxBufferSize) override;
-  std::tuple<double, double> closeFile() override;
+  OpenFileResult openFile(float streamSampleRate, int32_t streamChannelCount, int32_t streamMaxBufferSize) override;
+  CloseFileResult closeFile() override;
 
   bool writeAudioData(void *data, int numFrames) override;
 
  private:
-  std::shared_ptr<FFmpegAudioFileOptions> fileOptions_;
-
-  std::atomic<bool> isFileOpen_{false};
-  std::atomic<bool> isConverterRequired_{false};
-
-  AVCodecContextPtr encoderCtx_{nullptr};
-  AVFormatContextPtr formatCtx_{nullptr};
-  SwrContextPtr resampleCtx_{nullptr};
-  AVPacketPtr packet_{nullptr};
-  AVFramePtr frame_{nullptr};
+  av_unique_ptr<AVCodecContext> encoderCtx_{nullptr};
+  av_unique_ptr<AVFormatContext> formatCtx_{nullptr};
+  av_unique_ptr<SwrContext> resampleCtx_{nullptr};
+  av_unique_ptr<AVAudioFifo> audioFifo_{nullptr};
+  av_unique_ptr<AVPacket> packet_{nullptr};
+  av_unique_ptr<AVFrame> frame_{nullptr};
   AVStream* stream_{nullptr};
-  AVAudioFifoPtr audioFifo_{nullptr};
-  int64_t nextPts_;
-
-  bool initializeConverterIfNeeded();
-  bool initializeEncoder();
-
-  bool isFileOpen();
-  bool isConverterRequired();
+  unsigned int nextPts_{0};
+
+  std::chrono::steady_clock::time_point lastFlushTime_ = std::chrono::steady_clock::now();
+  int flushIntervalMs_;
+
+  // Initialization helper methods
+  Result<NoneType, std::string> initializeFormatContext(const AVCodec* codec);
+  Result<NoneType, std::string> configureAndOpenCodec(const AVCodec* codec);
+  Result<NoneType, std::string> initializeStream();
+  Result<NoneType, std::string> openIOAndWriteHeader();
+  Result<NoneType, std::string> initializeResampler(float inputRate, int inputChannels);
+  void initializeBuffers(int32_t maxBufferSize);
+
+  // Processing helper methods
+  bool resampleAndPushToFifo(void *data, int numFrames);
+  int processFifo(bool flush);
+  int writeEncodedPackets();
+  int prepareFrameForEncoding(int64_t samplesToRead);
+
+  // Finalization helper methods
+  CloseFileResult finalizeOutput();
 };
 
+} // namespace android::ffmpeg
+
 } // namespace audioapi

package/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/ptrs.hpp

@@ -0,0 +1,48 @@
+extern "C" {
+#include <libavcodec/avcodec.h>
+#include <libavformat/avformat.h>
+#include <libavutil/audio_fifo.h>
+#include <libswresample/swresample.h>
+}
+
+#include <audioapi/android/core/utils/ffmpegBackend/utils.h>
+
+namespace audioapi::android::ffmpeg {
+
+template<> inline void AvDtor<AVCodecContext>::operator()(AVCodecContext* ctx) const {
+  if (ctx != nullptr) {
+    avcodec_free_context(&ctx);
+  }
+}
+
+template<> inline void AvDtor<AVFormatContext>::operator()(AVFormatContext* ctx) const {
+  if (ctx != nullptr) {
+    avformat_free_context(ctx);
+  }
+}
+
+template<> inline void AvDtor<AVFrame>::operator()(AVFrame* frame) const {
+  if (frame != nullptr) {
+    av_frame_free(&frame);
+  }
+}
+
+template<> inline void AvDtor<AVPacket>::operator()(AVPacket* packet) const {
+  if (packet != nullptr) {
+    av_packet_free(&packet);
+  }
+}
+
+template<> inline void AvDtor<SwrContext>::operator()(SwrContext* ctx) const {
+  if (ctx != nullptr) {
+    swr_free(&ctx);
+  }
+}
+
+template<> inline void AvDtor<AVAudioFifo>::operator()(AVAudioFifo* fifo) const {
+  if (fifo != nullptr) {
+    av_audio_fifo_free(fifo);
+  }
+}
+
+} // namespace audioapi::android::ffmpeg

package/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/utils.cpp

@@ -0,0 +1,110 @@
+extern "C" {
+#include <libavcodec/avcodec.h>
+}
+
+#include <audioapi/android/core/utils/ffmpegBackend/utils.h>
+
+#include <audioapi/android/core/utils/FileOptions.h>
+#include <audioapi/utils/AudioFileProperties.h>
+
+#include <memory>
+#include <string>
+
+namespace audioapi::android::ffmpeg {
+
+/// @brief Get the PCM codec ID based on the bit depth.
+/// Note: This function returns only PCM codec IDs and its different from getSampleFormat. :)
+/// @param properties The audio file properties.
+/// @return The corresponding PCM AVCodecID.
+AVCodecID getPCMCodecID(const std::shared_ptr<AudioFileProperties> &properties) {
+  switch (properties->bitDepth) {
+    case AudioFileProperties::BitDepth::Bit16:
+      return AV_CODEC_ID_PCM_S16LE;
+    case AudioFileProperties::BitDepth::Bit24:
+      return AV_CODEC_ID_PCM_S24LE;
+    case AudioFileProperties::BitDepth::Bit32:
+      return AV_CODEC_ID_PCM_F32LE;
+    default:
+      return AV_CODEC_ID_PCM_F32LE;
+  }
+}
+
+/// @brief Get the codec ID based on the audio file properties.
+/// Note: PCM codec is used with wav and caf formats as both are uncompressed formats.
+/// @param properties The audio file properties.
+/// @return The corresponding AVCodecID.
+AVCodecID getCodecID(const std::shared_ptr<AudioFileProperties> &properties) {
+  switch (properties->format) {
+    case AudioFileProperties::Format::WAV:
+    case AudioFileProperties::Format::CAF:
+      return getPCMCodecID(properties);
+    case AudioFileProperties::Format::M4A:
+      return AV_CODEC_ID_AAC;
+    case AudioFileProperties::Format::FLAC:
+      return AV_CODEC_ID_FLAC;
+    default:
+      return AV_CODEC_ID_AAC;
+  }
+}
+
+/// @brief Returns the appropriate AVSampleFormat for codecs that require it. (non-PCM codecs)
+/// @param properties The audio file properties.
+/// @return The corresponding AVSampleFormat.
+AVSampleFormat getSampleFormat(const std::shared_ptr<AudioFileProperties> &properties) {
+  if (properties->format == AudioFileProperties::Format::M4A) {
+    return AV_SAMPLE_FMT_FLTP;
+  }
+
+  switch (properties->bitDepth) {
+    case AudioFileProperties::BitDepth::Bit16:
+      return AV_SAMPLE_FMT_S16;
+    case AudioFileProperties::BitDepth::Bit24:
+      return AV_SAMPLE_FMT_S32;
+    case AudioFileProperties::BitDepth::Bit32:
+      return AV_SAMPLE_FMT_FLT;
+    default:
+      return AV_SAMPLE_FMT_FLT;
+  }
+}
+
+/// @brief Finds the appropriate codec based on the audio file properties.
+/// @param properties The audio file properties.
+/// @return A pointer to the AVCodec.
+const AVCodec *getCodec(const std::shared_ptr<AudioFileProperties> &properties) {
+  return avcodec_find_encoder(getCodecID(properties));
+}
+
+/// @brief Returns the appropriate muxer name based on the audio file properties.
+/// Note: most of the time, the muxer name is same as the file extension, (M4A uses MP4 muxer :))
+/// thus this is kept separate from format -> extension mapping.
+/// @param properties The audio file properties.
+/// @return The corresponding muxer name.
+std::string getMuxerName(const std::shared_ptr<AudioFileProperties> &properties) {
+  switch (properties->format) {
+    case AudioFileProperties::Format::WAV:
+      return "wav";
+    case AudioFileProperties::Format::CAF:
+      return "caf";
+    case AudioFileProperties::Format::M4A:
+      return "mp4";
+    case AudioFileProperties::Format::FLAC:
+      return "flac";
+    default:
+      return "mp4";
+  }
+}
+
+/// @brief Parses the FFmpeg error int code into a human-readable string.
+/// @param errorCode The FFmpeg error code.
+/// @return A human-readable string describing the error.
+std::string parseErrorCode(int errorCode) {
+  char errorBuffer[AV_ERROR_MAX_STRING_SIZE];
+
+  if (av_strerror(errorCode, errorBuffer, sizeof(errorBuffer)) < 0) {
+    return "Unknown FFmpeg error: " + std::to_string(errorCode);
+  }
+
+  return std::string(errorBuffer);
+}
+
+} // namespace audioapi::android::ffmpeg

package/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/utils.h

@@ -0,0 +1,34 @@
+#pragma once
+
+extern "C" {
+#include <libavcodec/avcodec.h>
+}
+
+#include <string>
+#include <memory>
+
+namespace audioapi {
+
+class AudioFileProperties;
+
+namespace android::ffmpeg {
+
+template <typename AVT>
+struct AvDtor {
+  void operator()(AVT* ptr) const;
+};
+
+template<typename AVT>
+using av_unique_ptr = std::unique_ptr<AVT, AvDtor<AVT>>;
+
+AVCodecID getPCMCodecID(const std::shared_ptr<AudioFileProperties> &properties);
+AVCodecID getCodecID(const std::shared_ptr<AudioFileProperties> &properties);
+AVSampleFormat getSampleFormat(const std::shared_ptr<AudioFileProperties> &properties);
+const AVCodec* getCodec(const std::shared_ptr<AudioFileProperties> &properties);
+std::string getMuxerName(const std::shared_ptr<AudioFileProperties> &properties);
+
+std::string parseErrorCode(int errorCode);
+
+} // namespace android::ffmpeg
+
+} // namespace audioapi