cleanup and fix windows builds

Author: prevter

CMakeLists.txt

@@ -45,14 +45,14 @@ if (WIN32)
         ${CMAKE_SOURCE_DIR}/lib/aom.lib
         ${CMAKE_SOURCE_DIR}/lib/vpx.lib
         ${CMAKE_SOURCE_DIR}/lib/openh264.lib
-        ${CMAKE_SOURCE_DIR}/lib/ws2_32.lib
-        ${CMAKE_SOURCE_DIR}/lib/mfplat.lib
-        ${CMAKE_SOURCE_DIR}/lib/mf.lib
-        ${CMAKE_SOURCE_DIR}/lib/secur32.lib
-        ${CMAKE_SOURCE_DIR}/lib/crypt32.lib
-        ${CMAKE_SOURCE_DIR}/lib/mfuuid.lib
-        ${CMAKE_SOURCE_DIR}/lib/bcrypt.lib
-        ${CMAKE_SOURCE_DIR}/lib/strmiids.lib
+        ws2_32.lib
+        mfplat.lib
+        mf.lib
+        secur32.lib
+        crypt32.lib
+        mfuuid.lib
+        bcrypt.lib
+        strmiids.lib
     ) # windows
 elseif (ANDROID) 
     if (ANDROID_ABI STREQUAL "arm64-v8a")

mod.json

@@ -1,5 +1,5 @@
 {
-    "geode": "3.9.0",
+    "geode": "4.0.0",
     "gd": {
         "win": "*",
         "android": "*",

src/audio_mixer.cpp

@@ -1,6 +1,7 @@
 #include "audio_mixer.hpp"
 
 #include <iostream>
+#include <utility>
 
 extern "C" {
     #include <libavcodec/avcodec.h>
@@ -87,15 +88,14 @@ std::vector<float> readAudioFile(const char *filename, int targetSampleRate, AVS
 	std::vector<float> audioFrames;
 
 	float *convertBuffer[2];
-    convertBuffer[0] = (float *)av_malloc(4096 * sizeof(float));
-    convertBuffer[1] = (float *)av_malloc(4096 * sizeof(float));
+    convertBuffer[0] = static_cast<float *>(av_malloc(4096 * sizeof(float)));
+    convertBuffer[1] = static_cast<float *>(av_malloc(4096 * sizeof(float)));
 
     while (av_read_frame(formatContext, &packet) >= 0) {
         if (packet.stream_index == audioStreamIndex && avcodec_send_packet(codecContext, &packet) == 0) {
                 while (avcodec_receive_frame(codecContext, frame) == 0) {
-                    int ret = swr_convert(swr, (uint8_t **)convertBuffer, 4096,
-                                        (const uint8_t **)frame->data,
-                                        frame->nb_samples);
+                    int ret = swr_convert(swr, reinterpret_cast<uint8_t **>(convertBuffer), 4096,
+                                        frame->data, frame->nb_samples);
                     if (ret < 0) {
                         char errbuf[AV_ERROR_MAX_STRING_SIZE];
                         av_strerror(ret, errbuf, AV_ERROR_MAX_STRING_SIZE);
@@ -125,7 +125,7 @@ std::vector<float> readAudioFile(const char *filename, int targetSampleRate, AVS
 
 namespace ffmpeg {
     void AudioMixer::mixVideoAudio(std::filesystem::path videoFile, std::filesystem::path audioFile, std::filesystem::path outputMp4File) {
-        const int frameSize = 1024;
+        constexpr int frameSize = 1024;
 
         AVFormatContext* wavFormatContext = nullptr;
         if (avformat_open_input(&wavFormatContext, audioFile.string().c_str(), nullptr, nullptr) < 0) {
@@ -137,7 +137,7 @@ namespace ffmpeg {
 
         std::vector<float> raw = readAudioFile(audioFile.string().c_str(), 44100, AV_SAMPLE_FMT_FLTP, &inputAudioParams);
 
-        mixVideoRaw(videoFile, raw, outputMp4File, inputAudioParams.sample_rate);
+        mixVideoRaw(std::move(videoFile), raw, std::move(outputMp4File), inputAudioParams.sample_rate);
 
         avformat_close_input(&wavFormatContext);
     }
@@ -182,8 +182,8 @@ namespace ffmpeg {
             geode::log::error("Failed to create audio stream.");
             return;
         }
-        
-        const int channels = 2;
+
+        constexpr int channels = 2;
 
         outputAudioStream->codecpar->codec_tag = 0;
         outputAudioStream->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
@@ -211,7 +211,7 @@ namespace ffmpeg {
         audio_codec_context_encoder->sample_rate = sampleRate;
         audio_codec_context_encoder->ch_layout = AV_CHANNEL_LAYOUT_STEREO;
         audio_codec_context_encoder->sample_fmt = AV_SAMPLE_FMT_FLTP;
-        audio_codec_context_encoder->time_base = AVRational{1, (int)sampleRate};
+        audio_codec_context_encoder->time_base = AVRational{1, static_cast<int>(sampleRate)};
 
         int ret = avcodec_open2(audio_codec_context_encoder, audioCodec, nullptr);
         if (ret < 0) {
@@ -289,7 +289,7 @@ namespace ffmpeg {
 
             AVPacket audioPacket;
             av_init_packet(&audioPacket);
-            audioPacket.data = NULL;
+            audioPacket.data = nullptr;
             audioPacket.size = 0;
 
             while (true) {

src/recorder.cpp

@@ -21,8 +21,8 @@ std::vector<std::string> Recorder::getAvailableCodecs() {
     while ((codec = av_codec_iterate(&iter))) {
         if(codec->type == AVMEDIA_TYPE_VIDEO &&
                 (codec->id == AV_CODEC_ID_H264 || codec->id == AV_CODEC_ID_HEVC || codec->id == AV_CODEC_ID_VP8 || codec->id == AV_CODEC_ID_VP9 || codec->id == AV_CODEC_ID_AV1 || codec->id == AV_CODEC_ID_MPEG4) &&
-                avcodec_find_encoder_by_name(codec->name) != nullptr && codec->pix_fmts && std::find(vec.begin(), vec.end(), std::string(codec->name)) == vec.end())
-            vec.push_back(codec->name);
+                avcodec_find_encoder_by_name(codec->name) != nullptr && codec->pix_fmts && std::ranges::find(vec, std::string(codec->name)) == vec.end())
+            vec.emplace_back(codec->name);
     }
 
     return vec;
@@ -80,7 +80,7 @@ bool Recorder::init(const RenderSettings& settings) {
     const AVPixelFormat *pix_fmt = m_codec->pix_fmts;
     if (pix_fmt) {
         while (*pix_fmt != AV_PIX_FMT_NONE) {
-            if(*pix_fmt == (AVPixelFormat)settings.m_pixelFormat)
+            if(*pix_fmt == static_cast<AVPixelFormat>(settings.m_pixelFormat))
                 m_codecContext->pix_fmt = *pix_fmt;
             ++pix_fmt;
         }
@@ -93,7 +93,7 @@ bool Recorder::init(const RenderSettings& settings) {
     else
         geode::log::info("Codec {} supports pixel format.", settings.m_codec);
 
-    if (avcodec_open2(m_codecContext, m_codec, NULL) < 0) {
+    if (avcodec_open2(m_codecContext, m_codec, nullptr) < 0) {
         geode::log::error("Could not open codec.");
         return false;
     }
@@ -111,13 +111,13 @@ bool Recorder::init(const RenderSettings& settings) {
             return false;
     }
 
-    if (avformat_write_header(m_formatContext, NULL) < 0) {
+    if (avformat_write_header(m_formatContext, nullptr) < 0) {
         geode::log::error("Could not write header.");
         return false;
     }
 
-    m_swsCtx = sws_getContext(m_codecContext->width, m_codecContext->height, (AVPixelFormat)settings.m_pixelFormat, m_codecContext->width,
-        m_codecContext->height, m_codecContext->pix_fmt, SWS_BILINEAR, NULL, NULL, NULL);
+    m_swsCtx = sws_getContext(m_codecContext->width, m_codecContext->height, static_cast<AVPixelFormat>(settings.m_pixelFormat), m_codecContext->width,
+        m_codecContext->height, m_codecContext->pix_fmt, SWS_BILINEAR, nullptr, nullptr, nullptr);
 
     if (!m_swsCtx) {
         geode::log::error("Could not create sws context.");
@@ -178,7 +178,7 @@ bool Recorder::writeFrame(const std::vector<uint8_t>& frameData) {
         ret = avcodec_receive_packet(m_codecContext, m_packet);
         if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
             break;
-        else if (ret < 0)
+        if (ret < 0)
             return false;
 
         av_packet_rescale_ts(m_packet, m_codecContext->time_base, m_videoStream->time_base);
@@ -197,7 +197,7 @@ void Recorder::stop() {
 
     m_init = false;
 
-    avcodec_send_frame(m_codecContext, NULL);
+    avcodec_send_frame(m_codecContext, nullptr);
     while (avcodec_receive_packet(m_codecContext, m_packet) == 0) {
         av_packet_rescale_ts(m_packet, m_codecContext->time_base, m_videoStream->time_base);
         m_packet->stream_index = m_videoStream->index;