bump version, remove unused param, few cleanups

Author: prevter

include/audio_mixer.hpp

@@ -24,9 +24,11 @@ class FFMPEG_API_DLL AudioMixer {
     void mixVideoAudio(std::filesystem::path videoFile, std::filesystem::path audioFile, std::filesystem::path outputMp4File);
 
     /**
+     * @deprecated sampleRate parameter is no longer used. Use the other overload of this function instead.
+     *
      * @brief Mixes a video file and raw audio data into a single MP4 output.
      *
-     * This function takes an input video file and raw audio data (in the form of a vector of floating-point samples), 
+     * This function takes an input video file and raw audio data (in the form of a vector of floating-point samples),
      * and merges them into a single MP4 output file.
      *
      * @param videoFile The path to the input video file.
@@ -37,7 +39,22 @@ class FFMPEG_API_DLL AudioMixer {
      * @warning The raw audio data is expected to be stereo (dual-channel). Using mono or multi-channel audio might lead to issues.
      * @warning The video file is expected to contain a single video stream. Only the first video stream will be copied.
      */
-    void mixVideoRaw(std::filesystem::path videoFile, const std::vector<float>& raw, std::filesystem::path outputMp4File, uint32_t sampleRate);
+    [[deprecated]] void mixVideoRaw(std::filesystem::path videoFile, const std::vector<float>& raw, std::filesystem::path outputMp4File, uint32_t sampleRate);
+
+    /**
+     * @brief Mixes a video file and raw audio data into a single MP4 output.
+     *
+     * This function takes an input video file and raw audio data (in the form of a vector of floating-point samples),
+     * and merges them into a single MP4 output file.
+     *
+     * @param videoFile The path to the input video file.
+     * @param raw A vector containing the raw audio data (floating-point samples).
+     * @param outputMp4File The path where the output MP4 file will be saved.
+     *
+     * @warning The raw audio data is expected to be stereo (dual-channel). Using mono or multi-channel audio might lead to issues.
+     * @warning The video file is expected to contain a single video stream. Only the first video stream will be copied.
+     */
+    void mixVideoRaw(const std::filesystem::path& videoFile, const std::vector<float>& raw, const std::filesystem::path &outputMp4File);
 };
 
 }

mod.json

@@ -13,7 +13,7 @@
     },
     "id": "eclipse.ffmpeg-api",
     "name": "FFmpeg API",
-    "version": "v1.1.1",
+    "version": "v1.1.2",
     "developers": ["Eclipse Team", "maxnu"],
     "description": "Interaction with FFmpeg made easy",
     "tags": ["utility", "offline", "developer"],

src/audio_mixer.cpp

@@ -147,8 +147,8 @@ std::vector<float> resampleAudio(const std::vector<float>& inputAudio, int input
 		return {};
 	}
 
-    const int chunkSize = 4096;
-    const int numChannels = 2;
+    constexpr int chunkSize = 4096;
+    constexpr int numChannels = 2;
 
     int maxOutputSamples = av_rescale_rnd(chunkSize, targetSampleRate, inputSampleRate, AV_ROUND_UP);
     std::vector<float> outputAudio;
@@ -193,13 +193,18 @@ namespace ffmpeg {
 
         std::vector<float> raw = readAudioFile(audioFile.string().c_str(), 44100, AV_SAMPLE_FMT_FLTP, &inputAudioParams);
 
-        mixVideoRaw(std::move(videoFile), raw, std::move(outputMp4File), inputAudioParams.sample_rate);
+        mixVideoRaw(videoFile, raw, outputMp4File);
 
         avformat_close_input(&wavFormatContext);
     }
 
-    void AudioMixer::mixVideoRaw(std::filesystem::path videoFile, const std::vector<float>& raw, std::filesystem::path outputMp4File, uint32_t sampleRate) {
-        const int frameSize = 1024; 
+    void AudioMixer::mixVideoRaw(std::filesystem::path videoFile, const std::vector<float>& raw, std::filesystem::path outputMp4File, uint32_t) {
+        mixVideoRaw(videoFile, raw, outputMp4File);
+    }
+
+    void AudioMixer::mixVideoRaw(const std::filesystem::path& videoFile, const std::vector<float>& raw, const std::filesystem::path &outputMp4File) {
+        constexpr int frameSize = 1024;
+    	constexpr uint32_t sampleRate = 44100;
 
         AVFormatContext* videoFormatContext = nullptr;
         if (avformat_open_input(&videoFormatContext, videoFile.string().c_str(), nullptr, nullptr) < 0) {
@@ -349,18 +354,17 @@ namespace ffmpeg {
                 continue;
             }
 
-            AVPacket audioPacket;
-            av_init_packet(&audioPacket);
-            audioPacket.data = nullptr;
-            audioPacket.size = 0;
+            AVPacket* audioPacket = av_packet_alloc();
+            audioPacket->data = nullptr;
+            audioPacket->size = 0;
 
             while (true) {
-                int ret = avcodec_receive_packet(audio_codec_context_encoder, &audioPacket);
+                int ret = avcodec_receive_packet(audio_codec_context_encoder, audioPacket);
                 if (ret == 0) {
-                    av_packet_rescale_ts(&audioPacket, audio_codec_context_encoder->time_base, outputAudioStream->time_base);
-                    audioPacket.stream_index = 1;
-                    av_interleaved_write_frame(outputFormatContext, &audioPacket);
-                    av_packet_unref(&audioPacket);
+                    av_packet_rescale_ts(audioPacket, audio_codec_context_encoder->time_base, outputAudioStream->time_base);
+                    audioPacket->stream_index = 1;
+                    av_interleaved_write_frame(outputFormatContext, audioPacket);
+                    av_packet_unref(audioPacket);
                 } else if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
                     break;
                 else {

src/recorder.cpp

@@ -80,8 +80,7 @@ bool Recorder::init(const RenderSettings& settings) {
     m_codecContext->pix_fmt = AV_PIX_FMT_NONE;
     m_videoStream->time_base = m_codecContext->time_base;
 
-    const AVPixelFormat *pix_fmt = m_codec->pix_fmts;
-    if (pix_fmt) {
+    if (const AVPixelFormat *pix_fmt = m_codec->pix_fmts) {
         while (*pix_fmt != AV_PIX_FMT_NONE) {
             if(*pix_fmt == static_cast<AVPixelFormat>(settings.m_pixelFormat))
                 m_codecContext->pix_fmt = *pix_fmt;
@@ -142,8 +141,7 @@ bool Recorder::init(const RenderSettings& settings) {
 
     m_packet = av_packet_alloc();
 
-    av_init_packet(m_packet);
-    m_packet->data = NULL;
+    m_packet->data = nullptr;
     m_packet->size = 0;
 
     int inputPixelFormat = (int)settings.m_pixelFormat;
@@ -191,7 +189,7 @@ bool Recorder::init(const RenderSettings& settings) {
     }
 
     m_swsCtx = sws_getContext(m_codecContext->width, m_codecContext->height, (AVPixelFormat)inputPixelFormat, m_codecContext->width,
-        m_codecContext->height, m_codecContext->pix_fmt, SWS_FAST_BILINEAR, NULL, NULL, NULL);
+        m_codecContext->height, m_codecContext->pix_fmt, SWS_FAST_BILINEAR, nullptr, nullptr, nullptr);
 
     if (!m_swsCtx) {
         geode::log::error("Could not create sws context.");
@@ -253,12 +251,16 @@ bool Recorder::writeFrame(const std::vector<uint8_t>& frameData) {
 
 void Recorder::filterFrame(AVFrame* inputFrame, AVFrame* outputFrame) {
     if (av_buffersrc_add_frame(m_buffersrcCtx, inputFrame) < 0) {
-        std::cerr << "Error feeding frame to filter graph.\n";
+        geode::log::error("Error feeding frame to filter graph.");
         avfilter_graph_free(&m_filterGraph);
         return;
     }
 
-    av_buffersink_get_frame(m_buffersinkCtx, outputFrame);
+    if (av_buffersink_get_frame(m_buffersinkCtx, outputFrame) < 0) {
+        geode::log::error("Error retrieving frame from filter graph.");
+        av_frame_unref(outputFrame);
+        return;
+    }
 }
 
 void Recorder::stop() {
@@ -290,6 +292,10 @@ void Recorder::stop() {
         av_frame_free(&m_filteredFrame);
     }
 
+    if (m_hwDevice) {
+        av_buffer_unref(&m_hwDevice);
+    }
+
     av_packet_free(&m_packet);
 }