style(*): add .clang-format and format all files

Signed-off-by: k4yt3x <i@k4yt3x.com>

.clang-format

@@ -0,0 +1,8 @@
+BasedOnStyle: Chromium
+AlignAfterOpenBracket: BlockIndent
+AllowShortEnumsOnASingleLine: false
+BinPackArguments: false
+BreakStringLiterals: false
+ColumnLimit: 100
+IndentWidth: 4
+InsertBraces: true

include/libvideo2x/avutils.h

@@ -7,19 +7,19 @@ extern "C" {
 namespace video2x {
 namespace avutils {
 
-AVRational get_video_frame_rate(AVFormatContext *ifmt_ctx, int in_vstream_idx);
+AVRational get_video_frame_rate(AVFormatContext* ifmt_ctx, int in_vstream_idx);
 
-int64_t get_video_frame_count(AVFormatContext *ifmt_ctx, int in_vstream_idx);
+int64_t get_video_frame_count(AVFormatContext* ifmt_ctx, int in_vstream_idx);
 
-AVPixelFormat get_encoder_default_pix_fmt(const AVCodec *encoder, AVPixelFormat target_pix_fmt);
+AVPixelFormat get_encoder_default_pix_fmt(const AVCodec* encoder, AVPixelFormat target_pix_fmt);
 
-float get_frame_diff(AVFrame *frame1, AVFrame *frame2);
+float get_frame_diff(AVFrame* frame1, AVFrame* frame2);
 
-void av_bufferref_deleter(AVBufferRef *bufferref);
+void av_bufferref_deleter(AVBufferRef* bufferref);
 
-void av_frame_deleter(AVFrame *frame);
+void av_frame_deleter(AVFrame* frame);
 
-void av_packet_deleter(AVPacket *packet);
+void av_packet_deleter(AVPacket* packet);
 
 }  // namespace avutils
 }  // namespace video2x

include/libvideo2x/conversions.h

@@ -11,13 +11,13 @@ namespace video2x {
 namespace conversions {
 
 // Convert AVFrame to another pixel format
-AVFrame *convert_avframe_pix_fmt(AVFrame *src_frame, AVPixelFormat pix_fmt);
+AVFrame* convert_avframe_pix_fmt(AVFrame* src_frame, AVPixelFormat pix_fmt);
 
 // Convert AVFrame to ncnn::Mat
-ncnn::Mat avframe_to_ncnn_mat(AVFrame *frame);
+ncnn::Mat avframe_to_ncnn_mat(AVFrame* frame);
 
 // Convert ncnn::Mat to AVFrame
-AVFrame *ncnn_mat_to_avframe(const ncnn::Mat &mat, AVPixelFormat pix_fmt);
+AVFrame* ncnn_mat_to_avframe(const ncnn::Mat& mat, AVPixelFormat pix_fmt);
 
 }  // namespace conversions
 }  // namespace video2x

include/libvideo2x/decoder.h

@@ -15,18 +15,18 @@ class Decoder {
     Decoder();
     ~Decoder();
 
-    int init(AVHWDeviceType hw_type, AVBufferRef *hw_ctx, const std::filesystem::path &in_fpath);
+    int init(AVHWDeviceType hw_type, AVBufferRef* hw_ctx, const std::filesystem::path& in_fpath);
 
-    AVFormatContext *get_format_context() const;
+    AVFormatContext* get_format_context() const;
-    AVCodecContext *get_codec_context() const;
+    AVCodecContext* get_codec_context() const;
     int get_video_stream_index() const;
 
    private:
     static AVPixelFormat hw_pix_fmt_;
-    static AVPixelFormat get_hw_format(AVCodecContext *ctx, const AVPixelFormat *pix_fmts);
+    static AVPixelFormat get_hw_format(AVCodecContext* ctx, const AVPixelFormat* pix_fmts);
 
-    AVFormatContext *fmt_ctx_;
+    AVFormatContext* fmt_ctx_;
-    AVCodecContext *dec_ctx_;
+    AVCodecContext* dec_ctx_;
     int in_vstream_idx_;
 };
 

include/libvideo2x/encoder.h

@@ -54,30 +54,30 @@ class Encoder {
     ~Encoder();
 
     int init(
-        AVBufferRef *hw_ctx,
+        AVBufferRef* hw_ctx,
-        const std::filesystem::path &out_fpath,
+        const std::filesystem::path& out_fpath,
-        AVFormatContext *ifmt_ctx,
+        AVFormatContext* ifmt_ctx,
-        AVCodecContext *dec_ctx,
+        AVCodecContext* dec_ctx,
-        EncoderConfig &enc_cfg,
+        EncoderConfig& enc_cfg,
         int width,
         int height,
         int frm_rate_mul,
         int in_vstream_idx
     );
 
-    int write_frame(AVFrame *frame, int64_t frame_idx);
+    int write_frame(AVFrame* frame, int64_t frame_idx);
     int flush();
 
-    AVCodecContext *get_encoder_context() const;
+    AVCodecContext* get_encoder_context() const;
-    AVFormatContext *get_format_context() const;
+    AVFormatContext* get_format_context() const;
-    int *get_stream_map() const;
+    int* get_stream_map() const;
     int get_output_video_stream_index() const;
 
    private:
-    AVFormatContext *ofmt_ctx_;
+    AVFormatContext* ofmt_ctx_;
-    AVCodecContext *enc_ctx_;
+    AVCodecContext* enc_ctx_;
     int out_vstream_idx_;
-    int *stream_map_;
+    int* stream_map_;
 };
 
 }  // namespace encoder

include/libvideo2x/filter_libplacebo.h

@@ -19,7 +19,7 @@ class FilterLibplacebo : public Filter {
     // Constructor
     FilterLibplacebo(
         uint32_t vk_device_index,
-        const std::filesystem::path &shader_path,
+        const std::filesystem::path& shader_path,
         int width,
         int height
     );
@@ -28,30 +28,30 @@ class FilterLibplacebo : public Filter {
     virtual ~FilterLibplacebo() override;
 
     // Initializes the filter with decoder and encoder contexts
-    int init(AVCodecContext *dec_ctx, AVCodecContext *enc_ctx, AVBufferRef *hw_ctx) override;
+    int init(AVCodecContext* dec_ctx, AVCodecContext* enc_ctx, AVBufferRef* hw_ctx) override;
 
     // Processes an input frame and returns the processed frame
-    int filter(AVFrame *in_frame, AVFrame **out_frame) override;
+    int filter(AVFrame* in_frame, AVFrame** out_frame) override;
 
     // Flushes any remaining frames
-    int flush(std::vector<AVFrame *> &flushed_frames) override;
+    int flush(std::vector<AVFrame*>& flushed_frames) override;
 
     // Returns the filter's type
     ProcessorType get_processor_type() const override { return ProcessorType::Libplacebo; }
 
     // Returns the filter's output dimensions
     void get_output_dimensions(
-        const ProcessorConfig &proc_cfg,
+        const ProcessorConfig& proc_cfg,
         int in_width,
         int in_height,
-        int &out_width,
+        int& out_width,
-        int &out_height
+        int& out_height
     ) const override;
 
    private:
-    AVFilterGraph *filter_graph_;
+    AVFilterGraph* filter_graph_;
-    AVFilterContext *buffersrc_ctx_;
+    AVFilterContext* buffersrc_ctx_;
-    AVFilterContext *buffersink_ctx_;
+    AVFilterContext* buffersink_ctx_;
     uint32_t vk_device_index_;
     const std::filesystem::path shader_path_;
     int width_;

include/libvideo2x/filter_realcugan.h

@@ -28,25 +28,25 @@ class FilterRealcugan : public Filter {
     virtual ~FilterRealcugan() override;
 
     // Initializes the filter with decoder and encoder contexts
-    int init(AVCodecContext *dec_ctx, AVCodecContext *enc_ctx, AVBufferRef *hw_ctx) override;
+    int init(AVCodecContext* dec_ctx, AVCodecContext* enc_ctx, AVBufferRef* hw_ctx) override;
 
     // Processes an input frame and returns the processed frame
-    int filter(AVFrame *in_frame, AVFrame **out_frame) override;
+    int filter(AVFrame* in_frame, AVFrame** out_frame) override;
 
     // Returns the filter's type
     ProcessorType get_processor_type() const override { return ProcessorType::RealCUGAN; }
 
     // Returns the filter's output dimensions
     void get_output_dimensions(
-        const ProcessorConfig &proc_cfg,
+        const ProcessorConfig& proc_cfg,
         int in_width,
         int in_height,
-        int &out_width,
+        int& out_width,
-        int &out_height
+        int& out_height
     ) const override;
 
    private:
-    RealCUGAN *realcugan_;
+    RealCUGAN* realcugan_;
     int gpuid_;
     bool tta_mode_;
     int scaling_factor_;

include/libvideo2x/filter_realesrgan.h

@@ -25,25 +25,25 @@ class FilterRealesrgan : public Filter {
     virtual ~FilterRealesrgan() override;
 
     // Initializes the filter with decoder and encoder contexts
-    int init(AVCodecContext *dec_ctx, AVCodecContext *enc_ctx, AVBufferRef *hw_ctx) override;
+    int init(AVCodecContext* dec_ctx, AVCodecContext* enc_ctx, AVBufferRef* hw_ctx) override;
 
     // Processes an input frame and returns the processed frame
-    int filter(AVFrame *in_frame, AVFrame **out_frame) override;
+    int filter(AVFrame* in_frame, AVFrame** out_frame) override;
 
     // Returns the filter's type
     ProcessorType get_processor_type() const override { return ProcessorType::RealESRGAN; }
 
     // Returns the filter's output dimensions
     void get_output_dimensions(
-        const ProcessorConfig &proc_cfg,
+        const ProcessorConfig& proc_cfg,
         int in_width,
         int in_height,
-        int &out_width,
+        int& out_width,
-        int &out_height
+        int& out_height
     ) const override;
 
    private:
-    RealESRGAN *realesrgan_;
+    RealESRGAN* realesrgan_;
     int gpuid_;
     bool tta_mode_;
     int scaling_factor_;

include/libvideo2x/fsutils.h

@@ -20,15 +20,15 @@ typedef std::wstring StringType;
 typedef std::string StringType;
 #endif
 
-bool filepath_is_readable(const std::filesystem::path &path);
+bool filepath_is_readable(const std::filesystem::path& path);
 
-std::filesystem::path find_resource_file(const std::filesystem::path &path);
+std::filesystem::path find_resource_file(const std::filesystem::path& path);
 
-std::string path_to_u8string(const std::filesystem::path &path);
+std::string path_to_u8string(const std::filesystem::path& path);
 
-std::string wstring_to_u8string(const fsutils::StringType &wstr);
+std::string wstring_to_u8string(const fsutils::StringType& wstr);
 
-fsutils::StringType path_to_string_type(const std::filesystem::path &path);
+fsutils::StringType path_to_string_type(const std::filesystem::path& path);
 
 fsutils::StringType to_string_type(int value);
 

include/libvideo2x/interpolator_rife.h

@@ -27,10 +27,10 @@ class InterpolatorRIFE : public Interpolator {
     virtual ~InterpolatorRIFE() override;
 
     // Initializes the interpolator with decoder and encoder contexts
-    int init(AVCodecContext *dec_ctx, AVCodecContext *enc_ctx, AVBufferRef *hw_ctx) override;
+    int init(AVCodecContext* dec_ctx, AVCodecContext* enc_ctx, AVBufferRef* hw_ctx) override;
 
     // Processes an input frame and returns the processed frame
-    int interpolate(AVFrame *prev_frame, AVFrame *in_frame, AVFrame **out_frame, float time_step)
+    int interpolate(AVFrame* prev_frame, AVFrame* in_frame, AVFrame** out_frame, float time_step)
         override;
 
     // Returns the interpolator's type
@@ -38,15 +38,15 @@ class InterpolatorRIFE : public Interpolator {
 
     // Returns the interpolator's output dimensions
     void get_output_dimensions(
-        const ProcessorConfig &proc_cfg,
+        const ProcessorConfig& proc_cfg,
         int in_width,
         int in_height,
-        int &out_width,
+        int& out_width,
-        int &out_height
+        int& out_height
     ) const override;
 
    private:
-    RIFE *rife_;
+    RIFE* rife_;
     int gpuid_;
     bool tta_mode_;
     bool tta_temporal_mode_;

include/libvideo2x/libplacebo.h

@@ -11,14 +11,14 @@ namespace video2x {
 namespace processors {
 
 int init_libplacebo(
-    AVFilterGraph **filter_graph,
+    AVFilterGraph** filter_graph,
-    AVFilterContext **buffersrc_ctx,
+    AVFilterContext** buffersrc_ctx,
-    AVFilterContext **buffersink_ctx,
+    AVFilterContext** buffersink_ctx,
-    AVCodecContext *dec_ctx,
+    AVCodecContext* dec_ctx,
     int out_width,
     int out_height,
     uint32_t vk_device_index,
-    const std::filesystem::path &shader_path
+    const std::filesystem::path& shader_path
 );
 
 }  // namespace processors

include/libvideo2x/libvideo2x.h

@@ -51,33 +51,33 @@ class LIBVIDEO2X_API VideoProcessor {
 
    private:
     [[nodiscard]] int process_frames(
-        decoder::Decoder &decoder,
+        decoder::Decoder& decoder,
-        encoder::Encoder &encoder,
+        encoder::Encoder& encoder,
-        std::unique_ptr<processors::Processor> &processor
+        std::unique_ptr<processors::Processor>& processor
     );
 
-    [[nodiscard]] int write_frame(AVFrame *frame, encoder::Encoder &encoder);
+    [[nodiscard]] int write_frame(AVFrame* frame, encoder::Encoder& encoder);
 
     [[nodiscard]] inline int write_raw_packet(
-        AVPacket *packet,
+        AVPacket* packet,
-        AVFormatContext *ifmt_ctx,
+        AVFormatContext* ifmt_ctx,
-        AVFormatContext *ofmt_ctx,
+        AVFormatContext* ofmt_ctx,
-        int *stream_map
+        int* stream_map
     );
 
     [[nodiscard]] inline int process_filtering(
-        std::unique_ptr<processors::Processor> &processor,
+        std::unique_ptr<processors::Processor>& processor,
-        encoder::Encoder &encoder,
+        encoder::Encoder& encoder,
-        AVFrame *frame,
+        AVFrame* frame,
-        AVFrame *proc_frame
+        AVFrame* proc_frame
     );
 
     [[nodiscard]] inline int process_interpolation(
-        std::unique_ptr<processors::Processor> &processor,
+        std::unique_ptr<processors::Processor>& processor,
-        encoder::Encoder &encoder,
+        encoder::Encoder& encoder,
-        std::unique_ptr<AVFrame, decltype(&avutils::av_frame_deleter)> &prev_frame,
+        std::unique_ptr<AVFrame, decltype(&avutils::av_frame_deleter)>& prev_frame,
-        AVFrame *frame,
+        AVFrame* frame,
-        AVFrame *proc_frame
+        AVFrame* proc_frame
     );
 
     processors::ProcessorConfig proc_cfg_;

include/libvideo2x/logger_manager.h

@@ -14,20 +14,20 @@ namespace logger_manager {
 
 class LIBVIDEO2X_API LoggerManager {
    public:
-    LoggerManager(const LoggerManager &) = delete;
+    LoggerManager(const LoggerManager&) = delete;
-    LoggerManager &operator=(const LoggerManager &) = delete;
+    LoggerManager& operator=(const LoggerManager&) = delete;
 
-    static LoggerManager &instance();
+    static LoggerManager& instance();
 
     std::shared_ptr<spdlog::logger> logger();
 
     bool reconfigure_logger(
-        const std::string &logger_name,
+        const std::string& logger_name,
-        const std::vector<spdlog::sink_ptr> &sinks,
+        const std::vector<spdlog::sink_ptr>& sinks,
-        const std::string &pattern = "%+"
+        const std::string& pattern = "%+"
     );
 
-    bool set_log_level(const std::string &level_str);
+    bool set_log_level(const std::string& level_str);
 
     void hook_ffmpeg_logging();
     void unhook_ffmpeg_logging();

include/libvideo2x/processor.h

@@ -66,16 +66,16 @@ struct ProcessorConfig {
 class Processor {
    public:
     virtual ~Processor() = default;
-    virtual int init(AVCodecContext *dec_ctx, AVCodecContext *enc_ctx, AVBufferRef *hw_ctx) = 0;
+    virtual int init(AVCodecContext* dec_ctx, AVCodecContext* enc_ctx, AVBufferRef* hw_ctx) = 0;
-    virtual int flush(std::vector<AVFrame *> &) { return 0; }
+    virtual int flush(std::vector<AVFrame*>&) { return 0; }
     virtual ProcessingMode get_processing_mode() const = 0;
     virtual ProcessorType get_processor_type() const = 0;
     virtual void get_output_dimensions(
-        const ProcessorConfig &proc_cfg,
+        const ProcessorConfig& proc_cfg,
         int in_width,
         int in_height,
-        int &width,
+        int& width,
-        int &height
+        int& height
     ) const = 0;
 };
 
@@ -83,7 +83,7 @@ class Processor {
 class Filter : public Processor {
    public:
     ProcessingMode get_processing_mode() const override { return ProcessingMode::Filter; }
-    virtual int filter(AVFrame *in_frame, AVFrame **out_frame) = 0;
+    virtual int filter(AVFrame* in_frame, AVFrame** out_frame) = 0;
 };
 
 // Abstract base class for interpolators
@@ -91,7 +91,7 @@ class Interpolator : public Processor {
    public:
     ProcessingMode get_processing_mode() const override { return ProcessingMode::Interpolate; }
     virtual int
-    interpolate(AVFrame *prev_frame, AVFrame *in_frame, AVFrame **out_frame, float time_step) = 0;
+    interpolate(AVFrame* prev_frame, AVFrame* in_frame, AVFrame** out_frame, float time_step) = 0;
 };
 
 }  // namespace processors

include/libvideo2x/processor_factory.h

@@ -12,17 +12,17 @@ namespace processors {
 // Processor Factory Class
 class ProcessorFactory {
    public:
-    using Creator = std::function<std::unique_ptr<Processor>(const ProcessorConfig &, uint32_t)>;
+    using Creator = std::function<std::unique_ptr<Processor>(const ProcessorConfig&, uint32_t)>;
 
     // Singleton instance accessor
-    static ProcessorFactory &instance();
+    static ProcessorFactory& instance();
 
     // Register a processor type with its creation function
     void register_processor(ProcessorType type, Creator creator);
 
     // Create a processor instance based on configuration
     std::unique_ptr<Processor>
-    create_processor(const ProcessorConfig &proc_cfg, uint32_t vk_device_index) const;
+    create_processor(const ProcessorConfig& proc_cfg, uint32_t vk_device_index) const;
 
    private:
     // Private constructor for Singleton
@@ -32,7 +32,7 @@ class ProcessorFactory {
     std::unordered_map<ProcessorType, Creator> creators;
 
     // Static initializer for default processors
-    static void init_default_processors(ProcessorFactory &factory);
+    static void init_default_processors(ProcessorFactory& factory);
 };
 
 }  // namespace processors

src/avutils.cpp

@@ -15,7 +15,7 @@ extern "C" {
 namespace video2x {
 namespace avutils {
 
-AVRational get_video_frame_rate(AVFormatContext *ifmt_ctx, int in_vstream_idx) {
+AVRational get_video_frame_rate(AVFormatContext* ifmt_ctx, int in_vstream_idx) {
     AVRational frame_rate = ifmt_ctx->streams[in_vstream_idx]->avg_frame_rate;
     if (frame_rate.num == 0 && frame_rate.den == 0) {
         frame_rate = ifmt_ctx->streams[in_vstream_idx]->r_frame_rate;
@@ -32,7 +32,7 @@ AVRational get_video_frame_rate(AVFormatContext *ifmt_ctx, int in_vstream_idx) {
     return frame_rate;
 }
 
-int64_t get_video_frame_count(AVFormatContext *ifmt_ctx, int in_vstream_idx) {
+int64_t get_video_frame_count(AVFormatContext* ifmt_ctx, int in_vstream_idx) {
     // Use the 'nb_frames' field if it is available
     int64_t nb_frames = ifmt_ctx->streams[in_vstream_idx]->nb_frames;
     if (nb_frames != AV_NOPTS_VALUE && nb_frames > 0) {
@@ -67,15 +67,15 @@ int64_t get_video_frame_count(AVFormatContext *ifmt_ctx, int in_vstream_idx) {
     return static_cast<int64_t>(duration_secs * fps);
 }
 
-AVPixelFormat get_encoder_default_pix_fmt(const AVCodec *encoder, AVPixelFormat target_pix_fmt) {
+AVPixelFormat get_encoder_default_pix_fmt(const AVCodec* encoder, AVPixelFormat target_pix_fmt) {
     int ret;
     char errbuf[AV_ERROR_MAX_STRING_SIZE];
 
     // Retrieve the list of supported pixel formats
 #if LIBAVCODEC_BUILD >= AV_VERSION_INT(61, 13, 100)
-    const AVPixelFormat *supported_pix_fmts = nullptr;
+    const AVPixelFormat* supported_pix_fmts = nullptr;
     ret = avcodec_get_supported_config(
-        nullptr, encoder, AV_CODEC_CONFIG_PIX_FORMAT, 0, (const void **)&supported_pix_fmts, nullptr
+        nullptr, encoder, AV_CODEC_CONFIG_PIX_FORMAT, 0, (const void**)&supported_pix_fmts, nullptr
     );
     if (ret < 0) {
         av_strerror(ret, errbuf, sizeof(errbuf));
@@ -93,11 +93,11 @@ AVPixelFormat get_encoder_default_pix_fmt(const AVCodec *encoder, AVPixelFormat
         }
     }
 #else
-    const AVPixelFormat *supported_pix_fmts = encoder->pix_fmts;
+    const AVPixelFormat* supported_pix_fmts = encoder->pix_fmts;
 #endif
 
     // Determine if the target pixel format has an alpha channel
-    const AVPixFmtDescriptor *desc = nullptr;
+    const AVPixFmtDescriptor* desc = nullptr;
     int has_alpha = 0;
     if (target_pix_fmt != AV_PIX_FMT_NONE) {
         desc = av_pix_fmt_desc_get(target_pix_fmt);
@@ -106,7 +106,7 @@ AVPixelFormat get_encoder_default_pix_fmt(const AVCodec *encoder, AVPixelFormat
 
     // Iterate over supported pixel formats to find the best match
     AVPixelFormat best_pix_fmt = AV_PIX_FMT_NONE;
-    for (const AVPixelFormat *p = supported_pix_fmts; *p != AV_PIX_FMT_NONE; p++) {
+    for (const AVPixelFormat* p = supported_pix_fmts; *p != AV_PIX_FMT_NONE; p++) {
         if (target_pix_fmt != AV_PIX_FMT_NONE) {
             best_pix_fmt =
                 av_find_best_pix_fmt_of_2(best_pix_fmt, *p, target_pix_fmt, has_alpha, nullptr);
@@ -136,7 +136,7 @@ AVPixelFormat get_encoder_default_pix_fmt(const AVCodec *encoder, AVPixelFormat
 }
 
 [[gnu::target_clones("arch=x86-64-v4", "arch=x86-64-v3", "default")]]
-float get_frame_diff(AVFrame *frame1, AVFrame *frame2) {
+float get_frame_diff(AVFrame* frame1, AVFrame* frame2) {
     if (!frame1 || !frame2) {
         logger()->error("Invalid frame(s) provided for comparison");
         return -1.0f;
@@ -152,8 +152,8 @@ float get_frame_diff(AVFrame *frame1, AVFrame *frame2) {
 
     // Convert both frames to the target pixel format using the provided function
     AVPixelFormat target_pix_fmt = AV_PIX_FMT_RGB24;
-    AVFrame *rgb_frame1 = conversions::convert_avframe_pix_fmt(frame1, target_pix_fmt);
+    AVFrame* rgb_frame1 = conversions::convert_avframe_pix_fmt(frame1, target_pix_fmt);
-    AVFrame *rgb_frame2 = conversions::convert_avframe_pix_fmt(frame2, target_pix_fmt);
+    AVFrame* rgb_frame2 = conversions::convert_avframe_pix_fmt(frame2, target_pix_fmt);
 
     if (!rgb_frame1 || !rgb_frame2) {
         logger()->error("Failed to convert frames to target pixel format");
@@ -171,8 +171,8 @@ float get_frame_diff(AVFrame *frame1, AVFrame *frame2) {
 
     // Calculate difference pixel by pixel
     for (int y = 0; y < height; y++) {
-        uint8_t *ptr1 = rgb_frame1->data[0] + y * rgb_frame1->linesize[0];
+        uint8_t* ptr1 = rgb_frame1->data[0] + y * rgb_frame1->linesize[0];
-        uint8_t *ptr2 = rgb_frame2->data[0] + y * rgb_frame2->linesize[0];
+        uint8_t* ptr2 = rgb_frame2->data[0] + y * rgb_frame2->linesize[0];
         for (int x = 0; x < width * 3; x++) {
             sum_diff +=
                 static_cast<uint64_t>(ptr1[x] > ptr2[x] ? ptr1[x] - ptr2[x] : ptr2[x] - ptr1[x]);
@@ -191,14 +191,14 @@ float get_frame_diff(AVFrame *frame1, AVFrame *frame2) {
 }
 
 // Deleter for AVBufferRef unique_ptr
-void av_bufferref_deleter(AVBufferRef *bufferref) {
+void av_bufferref_deleter(AVBufferRef* bufferref) {
     if (bufferref != nullptr) {
         av_buffer_unref(&bufferref);
     }
 }
 
 // Deleter for AVFrame unique_ptr
-void av_frame_deleter(AVFrame *frame) {
+void av_frame_deleter(AVFrame* frame) {
     if (frame != nullptr) {
         av_frame_free(&frame);
         frame = nullptr;
@@ -206,7 +206,7 @@ void av_frame_deleter(AVFrame *frame) {
 }
 
 // Deleter for AVPacket unique_ptr
-void av_packet_deleter(AVPacket *packet) {
+void av_packet_deleter(AVPacket* packet) {
     if (packet != nullptr) {
         av_packet_unref(packet);
         av_packet_free(&packet);

src/conversions.cpp

@@ -12,8 +12,8 @@ namespace conversions {
 
 // Convert AVFrame format
 [[gnu::target_clones("arch=x86-64-v4", "arch=x86-64-v3", "default")]]
-AVFrame *convert_avframe_pix_fmt(AVFrame *src_frame, AVPixelFormat pix_fmt) {
+AVFrame* convert_avframe_pix_fmt(AVFrame* src_frame, AVPixelFormat pix_fmt) {
-    AVFrame *dst_frame = av_frame_alloc();
+    AVFrame* dst_frame = av_frame_alloc();
     if (dst_frame == nullptr) {
         logger()->error("Failed to allocate destination AVFrame.");
         return nullptr;
@@ -31,7 +31,7 @@ AVFrame *convert_avframe_pix_fmt(AVFrame *src_frame, AVPixelFormat pix_fmt) {
     }
 
     // Create a SwsContext for pixel format conversion
-    SwsContext *sws_ctx = sws_getContext(
+    SwsContext* sws_ctx = sws_getContext(
         src_frame->width,
         src_frame->height,
         static_cast<AVPixelFormat>(src_frame->format),
@@ -69,8 +69,8 @@ AVFrame *convert_avframe_pix_fmt(AVFrame *src_frame, AVPixelFormat pix_fmt) {
 
 // Convert AVFrame to ncnn::Mat by copying the data
 [[gnu::target_clones("arch=x86-64-v4", "arch=x86-64-v3", "default")]]
-ncnn::Mat avframe_to_ncnn_mat(AVFrame *frame) {
+ncnn::Mat avframe_to_ncnn_mat(AVFrame* frame) {
-    AVFrame *converted_frame = nullptr;
+    AVFrame* converted_frame = nullptr;
 
     // Convert to BGR24 format if necessary
     if (frame->format != AV_PIX_FMT_BGR24) {
@@ -90,10 +90,10 @@ ncnn::Mat avframe_to_ncnn_mat(AVFrame *frame) {
     ncnn::Mat ncnn_image = ncnn::Mat(width, height, static_cast<size_t>(3), 3);
 
     // Manually copy the pixel data from AVFrame to the new ncnn::Mat
-    const uint8_t *src_data = converted_frame->data[0];
+    const uint8_t* src_data = converted_frame->data[0];
     for (int y = 0; y < height; y++) {
-        uint8_t *dst_row = ncnn_image.row<uint8_t>(y);
+        uint8_t* dst_row = ncnn_image.row<uint8_t>(y);
-        const uint8_t *src_row = src_data + y * converted_frame->linesize[0];
+        const uint8_t* src_row = src_data + y * converted_frame->linesize[0];
 
         // Copy 3 channels (BGR) per pixel
         memcpy(dst_row, src_row, static_cast<size_t>(width) * 3);
@@ -109,11 +109,11 @@ ncnn::Mat avframe_to_ncnn_mat(AVFrame *frame) {
 
 // Convert ncnn::Mat to AVFrame with a specified pixel format (this part is unchanged)
 [[gnu::target_clones("arch=x86-64-v4", "arch=x86-64-v3", "default")]]
-AVFrame *ncnn_mat_to_avframe(const ncnn::Mat &mat, AVPixelFormat pix_fmt) {
+AVFrame* ncnn_mat_to_avframe(const ncnn::Mat& mat, AVPixelFormat pix_fmt) {
     int ret;
 
     // Step 1: Allocate a destination AVFrame for the specified pixel format
-    AVFrame *dst_frame = av_frame_alloc();
+    AVFrame* dst_frame = av_frame_alloc();
     if (!dst_frame) {
         logger()->error("Failed to allocate destination AVFrame.");
         return nullptr;
@@ -131,7 +131,7 @@ AVFrame *ncnn_mat_to_avframe(const ncnn::Mat &mat, AVPixelFormat pix_fmt) {
     }
 
     // Step 2: Convert ncnn::Mat to BGR AVFrame
-    AVFrame *bgr_frame = av_frame_alloc();
+    AVFrame* bgr_frame = av_frame_alloc();
     if (!bgr_frame) {
         logger()->error("Failed to allocate intermediate BGR AVFrame.");
         av_frame_free(&dst_frame);
@@ -152,15 +152,15 @@ AVFrame *ncnn_mat_to_avframe(const ncnn::Mat &mat, AVPixelFormat pix_fmt) {
 
     // Copy the pixel data from ncnn::Mat to the BGR AVFrame
     for (int y = 0; y < mat.h; y++) {
-        uint8_t *dst_row = bgr_frame->data[0] + y * bgr_frame->linesize[0];
+        uint8_t* dst_row = bgr_frame->data[0] + y * bgr_frame->linesize[0];
-        const uint8_t *src_row = mat.row<const uint8_t>(y);
+        const uint8_t* src_row = mat.row<const uint8_t>(y);
 
         // Copy 3 channels (BGR) per pixel
         memcpy(dst_row, src_row, static_cast<size_t>(mat.w) * 3);
     }
 
     // Step 3: Convert the BGR frame to the desired pixel format
-    SwsContext *sws_ctx = sws_getContext(
+    SwsContext* sws_ctx = sws_getContext(
         bgr_frame->width,
         bgr_frame->height,
         AV_PIX_FMT_BGR24,

src/decoder.cpp

@@ -22,8 +22,8 @@ Decoder::~Decoder() {
     }
 }
 
-AVPixelFormat Decoder::get_hw_format(AVCodecContext *, const AVPixelFormat *pix_fmts) {
+AVPixelFormat Decoder::get_hw_format(AVCodecContext*, const AVPixelFormat* pix_fmts) {
-    for (const AVPixelFormat *p = pix_fmts; *p != AV_PIX_FMT_NONE; p++) {
+    for (const AVPixelFormat* p = pix_fmts; *p != AV_PIX_FMT_NONE; p++) {
         if (*p == hw_pix_fmt_) {
             return *p;
         }
@@ -34,8 +34,8 @@ AVPixelFormat Decoder::get_hw_format(AVCodecContext *, const AVPixelFormat *pix_
 
 int Decoder::init(
     AVHWDeviceType hw_type,
-    AVBufferRef *hw_ctx,
+    AVBufferRef* hw_ctx,
-    const std::filesystem::path &in_fpath
+    const std::filesystem::path& in_fpath
 ) {
     int ret;
 
@@ -59,10 +59,10 @@ int Decoder::init(
     }
 
     int stream_index = ret;
-    AVStream *video_stream = fmt_ctx_->streams[stream_index];
+    AVStream* video_stream = fmt_ctx_->streams[stream_index];
 
     // Find the decoder for the video stream
-    const AVCodec *decoder = avcodec_find_decoder(video_stream->codecpar->codec_id);
+    const AVCodec* decoder = avcodec_find_decoder(video_stream->codecpar->codec_id);
     if (!decoder) {
         logger()->error(
             "Failed to find decoder for codec ID {}",
@@ -96,7 +96,7 @@ int Decoder::init(
 
         // Automatically determine the hardware pixel format
         for (int i = 0;; i++) {
-            const AVCodecHWConfig *config = avcodec_get_hw_config(decoder, i);
+            const AVCodecHWConfig* config = avcodec_get_hw_config(decoder, i);
             if (config == nullptr) {
                 logger()->error(
                     "Decoder {} does not support device type {}.",
@@ -124,11 +124,11 @@ int Decoder::init(
     return 0;
 }
 
-AVFormatContext *Decoder::get_format_context() const {
+AVFormatContext* Decoder::get_format_context() const {
     return fmt_ctx_;
 }
 
-AVCodecContext *Decoder::get_codec_context() const {
+AVCodecContext* Decoder::get_codec_context() const {
     return dec_ctx_;
 }
 

src/encoder.cpp

@@ -33,11 +33,11 @@ Encoder::~Encoder() {
 }
 
 int Encoder::init(
-    AVBufferRef *hw_ctx,
+    AVBufferRef* hw_ctx,
-    const std::filesystem::path &out_fpath,
+    const std::filesystem::path& out_fpath,
-    AVFormatContext *ifmt_ctx,
+    AVFormatContext* ifmt_ctx,
-    AVCodecContext *dec_ctx,
+    AVCodecContext* dec_ctx,
-    EncoderConfig &enc_cfg,
+    EncoderConfig& enc_cfg,
     int width,
     int height,
     int frm_rate_mul,
@@ -53,7 +53,7 @@ int Encoder::init(
     }
 
     // Find the encoder
-    const AVCodec *encoder = avcodec_find_encoder(enc_cfg.codec);
+    const AVCodec* encoder = avcodec_find_encoder(enc_cfg.codec);
     if (!encoder) {
         logger()->error(
             "Required video encoder not found for codec {}", avcodec_get_name(enc_cfg.codec)
@@ -62,7 +62,7 @@ int Encoder::init(
     }
 
     // Create a new video stream in the output file
-    AVStream *out_vstream = avformat_new_stream(ofmt_ctx_, nullptr);
+    AVStream* out_vstream = avformat_new_stream(ofmt_ctx_, nullptr);
     if (!out_vstream) {
         logger()->error("Failed to allocate the output video stream");
         return AVERROR_UNKNOWN;
@@ -150,7 +150,7 @@ int Encoder::init(
     }
 
     // Set extra AVOptions
-    for (const auto &[opt_name, opt_value] : enc_cfg.extra_opts) {
+    for (const auto& [opt_name, opt_value] : enc_cfg.extra_opts) {
         std::string opt_name_str = fsutils::wstring_to_u8string(opt_name);
         std::string opt_value_str = fsutils::wstring_to_u8string(opt_value);
         spdlog::debug("Setting encoder option '{}' to '{}'", opt_name_str, opt_value_str);
@@ -193,7 +193,7 @@ int Encoder::init(
     if (enc_cfg.copy_streams) {
         // Allocate the stream mape frame o
         stream_map_ =
-            reinterpret_cast<int *>(av_malloc_array(ifmt_ctx->nb_streams, sizeof(*stream_map_)));
+            reinterpret_cast<int*>(av_malloc_array(ifmt_ctx->nb_streams, sizeof(*stream_map_)));
         if (!stream_map_) {
             logger()->error("Could not allocate stream mapping");
             return AVERROR(ENOMEM);
@@ -201,8 +201,8 @@ int Encoder::init(
 
         // Map each input stream to an output stream
         for (int i = 0; i < static_cast<int>(ifmt_ctx->nb_streams); i++) {
-            AVStream *in_stream = ifmt_ctx->streams[i];
+            AVStream* in_stream = ifmt_ctx->streams[i];
-            AVCodecParameters *in_codecpar = in_stream->codecpar;
+            AVCodecParameters* in_codecpar = in_stream->codecpar;
 
             // Skip the input video stream as it's already processed
             if (i == in_vstream_idx) {
@@ -219,7 +219,7 @@ int Encoder::init(
             }
 
             // Create corresponding output stream for audio and subtitle streams
-            AVStream *out_stream = avformat_new_stream(ofmt_ctx_, nullptr);
+            AVStream* out_stream = avformat_new_stream(ofmt_ctx_, nullptr);
             if (!out_stream) {
                 logger()->error("Failed allocating output stream");
                 return AVERROR_UNKNOWN;
@@ -262,8 +262,8 @@ int Encoder::init(
 }
 
 [[gnu::target_clones("arch=x86-64-v4", "arch=x86-64-v3", "default")]]
-int Encoder::write_frame(AVFrame *frame, int64_t frame_idx) {
+int Encoder::write_frame(AVFrame* frame, int64_t frame_idx) {
-    AVFrame *converted_frame = nullptr;
+    AVFrame* converted_frame = nullptr;
     int ret;
 
     // Let the encoder decide the frame type
@@ -282,7 +282,7 @@ int Encoder::write_frame(AVFrame *frame, int64_t frame_idx) {
         converted_frame->pts = frame->pts;
     }
 
-    AVPacket *enc_pkt = av_packet_alloc();
+    AVPacket* enc_pkt = av_packet_alloc();
     if (!enc_pkt) {
         logger()->error("Could not allocate AVPacket");
         return AVERROR(ENOMEM);
@@ -336,7 +336,7 @@ int Encoder::write_frame(AVFrame *frame, int64_t frame_idx) {
 [[gnu::target_clones("arch=x86-64-v4", "arch=x86-64-v3", "default")]]
 int Encoder::flush() {
     int ret;
-    AVPacket *enc_pkt = av_packet_alloc();
+    AVPacket* enc_pkt = av_packet_alloc();
     if (!enc_pkt) {
         logger()->error("Could not allocate AVPacket");
         return AVERROR(ENOMEM);
@@ -382,11 +382,11 @@ int Encoder::flush() {
     return 0;
 }
 
-AVCodecContext *Encoder::get_encoder_context() const {
+AVCodecContext* Encoder::get_encoder_context() const {
     return enc_ctx_;
 }
 
-AVFormatContext *Encoder::get_format_context() const {
+AVFormatContext* Encoder::get_format_context() const {
     return ofmt_ctx_;
 }
 
@@ -394,7 +394,7 @@ int Encoder::get_output_video_stream_index() const {
     return out_vstream_idx_;
 }
 
-int *Encoder::get_stream_map() const {
+int* Encoder::get_stream_map() const {
     return stream_map_;
 }
 

src/filter_libplacebo.cpp

@@ -13,7 +13,7 @@ namespace processors {
 
 FilterLibplacebo::FilterLibplacebo(
     uint32_t vk_device_index,
-    const std::filesystem::path &shader_path,
+    const std::filesystem::path& shader_path,
     int width,
     int height
 )
@@ -40,7 +40,7 @@ FilterLibplacebo::~FilterLibplacebo() {
     }
 }
 
-int FilterLibplacebo::init(AVCodecContext *dec_ctx, AVCodecContext *enc_ctx, AVBufferRef *) {
+int FilterLibplacebo::init(AVCodecContext* dec_ctx, AVCodecContext* enc_ctx, AVBufferRef*) {
     // Construct the shader path
     std::filesystem::path shader_full_path;
     if (fsutils::filepath_is_readable(shader_path_)) {
@@ -85,7 +85,7 @@ int FilterLibplacebo::init(AVCodecContext *dec_ctx, AVCodecContext *enc_ctx, AVB
     return ret;
 }
 
-int FilterLibplacebo::filter(AVFrame *in_frame, AVFrame **out_frame) {
+int FilterLibplacebo::filter(AVFrame* in_frame, AVFrame** out_frame) {
     int ret;
 
     // Get the filtered frame
@@ -116,7 +116,7 @@ int FilterLibplacebo::filter(AVFrame *in_frame, AVFrame **out_frame) {
     return 0;
 }
 
-int FilterLibplacebo::flush(std::vector<AVFrame *> &flushed_frames) {
+int FilterLibplacebo::flush(std::vector<AVFrame*>& flushed_frames) {
     int ret = av_buffersrc_add_frame(buffersrc_ctx_, nullptr);
     if (ret < 0) {
         logger()->error("Error while flushing filter graph");
@@ -125,7 +125,7 @@ int FilterLibplacebo::flush(std::vector<AVFrame *> &flushed_frames) {
 
     // Retrieve all remaining frames from the filter graph
     while (1) {
-        AVFrame *filt_frame = av_frame_alloc();
+        AVFrame* filt_frame = av_frame_alloc();
         if (filt_frame == nullptr) {
             return AVERROR(ENOMEM);
         }
@@ -151,11 +151,11 @@ int FilterLibplacebo::flush(std::vector<AVFrame *> &flushed_frames) {
 }
 
 void FilterLibplacebo::get_output_dimensions(
-    const ProcessorConfig &proc_cfg,
+    const ProcessorConfig& proc_cfg,
     int,
     int,
-    int &out_width,
+    int& out_width,
-    int &out_height
+    int& out_height
 ) const {
     out_width = proc_cfg.width;
     out_height = proc_cfg.height;

src/filter_realcugan.cpp

@@ -38,7 +38,7 @@ FilterRealcugan::~FilterRealcugan() {
     }
 }
 
-int FilterRealcugan::init(AVCodecContext *dec_ctx, AVCodecContext *enc_ctx, AVBufferRef *) {
+int FilterRealcugan::init(AVCodecContext* dec_ctx, AVCodecContext* enc_ctx, AVBufferRef*) {
     // Construct the model paths using std::filesystem
     std::filesystem::path model_param_path;
     std::filesystem::path model_bin_path;
@@ -161,7 +161,7 @@ int FilterRealcugan::init(AVCodecContext *dec_ctx, AVCodecContext *enc_ctx, AVBu
     return 0;
 }
 
-int FilterRealcugan::filter(AVFrame *in_frame, AVFrame **out_frame) {
+int FilterRealcugan::filter(AVFrame* in_frame, AVFrame** out_frame) {
     int ret;
 
     // Convert the input frame to RGB24
@@ -193,11 +193,11 @@ int FilterRealcugan::filter(AVFrame *in_frame, AVFrame **out_frame) {
 }
 
 void FilterRealcugan::get_output_dimensions(
-    const ProcessorConfig &,
+    const ProcessorConfig&,
     int in_width,
     int in_height,
-    int &out_width,
+    int& out_width,
-    int &out_height
+    int& out_height
 ) const {
     out_width = in_width * scaling_factor_;
     out_height = in_height * scaling_factor_;

src/filter_realesrgan.cpp

@@ -32,7 +32,7 @@ FilterRealesrgan::~FilterRealesrgan() {
     }
 }
 
-int FilterRealesrgan::init(AVCodecContext *dec_ctx, AVCodecContext *enc_ctx, AVBufferRef *) {
+int FilterRealesrgan::init(AVCodecContext* dec_ctx, AVCodecContext* enc_ctx, AVBufferRef*) {
     // Construct the model paths using std::filesystem
     std::filesystem::path model_param_path;
     std::filesystem::path model_bin_path;
@@ -93,7 +93,7 @@ int FilterRealesrgan::init(AVCodecContext *dec_ctx, AVCodecContext *enc_ctx, AVB
     return 0;
 }
 
-int FilterRealesrgan::filter(AVFrame *in_frame, AVFrame **out_frame) {
+int FilterRealesrgan::filter(AVFrame* in_frame, AVFrame** out_frame) {
     int ret;
 
     // Convert the input frame to RGB24
@@ -125,11 +125,11 @@ int FilterRealesrgan::filter(AVFrame *in_frame, AVFrame **out_frame) {
 }
 
 void FilterRealesrgan::get_output_dimensions(
-    const ProcessorConfig &,
+    const ProcessorConfig&,
     int in_width,
     int in_height,
-    int &out_width,
+    int& out_width,
-    int &out_height
+    int& out_height
 ) const {
     out_width = in_width * scaling_factor_;
     out_height = in_height * scaling_factor_;

src/fsutils.cpp

@@ -54,11 +54,11 @@ static std::filesystem::path get_executable_directory() {
 }
 #endif  // _WIN32
 
-bool filepath_is_readable(const std::filesystem::path &path) {
+bool filepath_is_readable(const std::filesystem::path& path) {
 #if _WIN32
-    FILE *fp = _wfopen(path.c_str(), L"rb");
+    FILE* fp = _wfopen(path.c_str(), L"rb");
 #else   // _WIN32
-    FILE *fp = fopen(path.c_str(), "rb");
+    FILE* fp = fopen(path.c_str(), "rb");
 #endif  // _WIN32
     if (!fp) {
         return false;
@@ -68,7 +68,7 @@ bool filepath_is_readable(const std::filesystem::path &path) {
     return true;
 }
 
-std::filesystem::path find_resource_file(const std::filesystem::path &path) {
+std::filesystem::path find_resource_file(const std::filesystem::path& path) {
     if (filepath_is_readable(path)) {
         return path;
     }
@@ -80,7 +80,7 @@ std::filesystem::path find_resource_file(const std::filesystem::path &path) {
     return get_executable_directory() / path;
 }
 
-std::string path_to_u8string(const std::filesystem::path &path) {
+std::string path_to_u8string(const std::filesystem::path& path) {
 #if _WIN32
     std::wstring wide_path = path.wstring();
     int buffer_size =
@@ -99,7 +99,7 @@ std::string path_to_u8string(const std::filesystem::path &path) {
 }
 
 #ifdef _WIN32
-std::string wstring_to_u8string(const std::wstring &wstr) {
+std::string wstring_to_u8string(const std::wstring& wstr) {
     if (wstr.empty()) {
         return std::string();
     }
@@ -120,12 +120,12 @@ std::string wstring_to_u8string(const std::wstring &wstr) {
     return converted_str;
 }
 #else
-std::string wstring_to_u8string(const std::string &str) {
+std::string wstring_to_u8string(const std::string& str) {
     return str;
 }
 #endif
 
-fsutils::StringType path_to_string_type(const std::filesystem::path &path) {
+fsutils::StringType path_to_string_type(const std::filesystem::path& path) {
 #if _WIN32
     return path.wstring();
 #else

src/interpolator_rife.cpp

@@ -35,7 +35,7 @@ InterpolatorRIFE::~InterpolatorRIFE() {
     }
 }
 
-int InterpolatorRIFE::init(AVCodecContext *dec_ctx, AVCodecContext *enc_ctx, AVBufferRef *) {
+int InterpolatorRIFE::init(AVCodecContext* dec_ctx, AVCodecContext* enc_ctx, AVBufferRef*) {
     // Construct the model directory path using std::filesystem
     std::filesystem::path model_param_dir;
 
@@ -84,9 +84,9 @@ int InterpolatorRIFE::init(AVCodecContext *dec_ctx, AVCodecContext *enc_ctx, AVB
 }
 
 int InterpolatorRIFE::interpolate(
-    AVFrame *prev_frame,
+    AVFrame* prev_frame,
-    AVFrame *in_frame,
+    AVFrame* in_frame,
-    AVFrame **out_frame,
+    AVFrame** out_frame,
     float time_step
 ) {
     int ret;
@@ -123,11 +123,11 @@ int InterpolatorRIFE::interpolate(
 }
 
 void InterpolatorRIFE::get_output_dimensions(
-    const ProcessorConfig &,
+    const ProcessorConfig&,
     int in_width,
     int in_height,
-    int &out_width,
+    int& out_width,
-    int &out_height
+    int& out_height
 ) const {
     out_width = in_width;
     out_height = in_height;

src/libplacebo.cpp

@@ -17,19 +17,19 @@ namespace video2x {
 namespace processors {
 
 int init_libplacebo(
-    AVFilterGraph **filter_graph,
+    AVFilterGraph** filter_graph,
-    AVFilterContext **buffersrc_ctx,
+    AVFilterContext** buffersrc_ctx,
-    AVFilterContext **buffersink_ctx,
+    AVFilterContext** buffersink_ctx,
-    AVCodecContext *dec_ctx,
+    AVCodecContext* dec_ctx,
     int out_width,
     int out_height,
     uint32_t vk_device_index,
-    const std::filesystem::path &shader_path
+    const std::filesystem::path& shader_path
 ) {
     int ret;
 
     // Create the Vulkan hardware device context
-    AVBufferRef *vk_hw_device_ctx = nullptr;
+    AVBufferRef* vk_hw_device_ctx = nullptr;
     ret = av_hwdevice_ctx_create(
         &vk_hw_device_ctx, AV_HWDEVICE_TYPE_VULKAN, std::to_string(vk_device_index).c_str(), NULL, 0
     );
@@ -38,14 +38,14 @@ int init_libplacebo(
         vk_hw_device_ctx = nullptr;
     }
 
-    AVFilterGraph *graph = avfilter_graph_alloc();
+    AVFilterGraph* graph = avfilter_graph_alloc();
     if (!graph) {
         logger()->error("Unable to create filter graph.");
         return AVERROR(ENOMEM);
     }
 
     // Create buffer source
-    const AVFilter *buffersrc = avfilter_get_by_name("buffer");
+    const AVFilter* buffersrc = avfilter_get_by_name("buffer");
     if (!buffersrc) {
         logger()->error("Filter 'buffer' not found.");
         avfilter_graph_free(&graph);
@@ -65,7 +65,7 @@ int init_libplacebo(
 
     // Make a copy of the AVClass on the stack
     AVClass priv_class_copy = *buffersrc->priv_class;
-    AVClass *priv_class_copy_ptr = &priv_class_copy;
+    AVClass* priv_class_copy_ptr = &priv_class_copy;
 
     // Check if the colorspace option is supported
     if (av_opt_find(&priv_class_copy_ptr, "colorspace", NULL, 0, AV_OPT_SEARCH_FAKE_OBJ)) {
@@ -89,10 +89,10 @@ int init_libplacebo(
         return ret;
     }
 
-    AVFilterContext *last_filter = *buffersrc_ctx;
+    AVFilterContext* last_filter = *buffersrc_ctx;
 
     // Create the libplacebo filter
-    const AVFilter *libplacebo_filter = avfilter_get_by_name("libplacebo");
+    const AVFilter* libplacebo_filter = avfilter_get_by_name("libplacebo");
     if (!libplacebo_filter) {
         logger()->error("Filter 'libplacebo' not found.");
         avfilter_graph_free(&graph);
@@ -112,7 +112,7 @@ int init_libplacebo(
                               ":h=" + std::to_string(out_height) + ":custom_shader_path='" +
                               shader_path_string + "'";
 
-    AVFilterContext *libplacebo_ctx;
+    AVFilterContext* libplacebo_ctx;
     ret = avfilter_graph_create_filter(
         &libplacebo_ctx, libplacebo_filter, "libplacebo", filter_args.c_str(), NULL, graph
     );
@@ -139,7 +139,7 @@ int init_libplacebo(
     last_filter = libplacebo_ctx;
 
     // Create buffer sink
-    const AVFilter *buffersink = avfilter_get_by_name("buffersink");
+    const AVFilter* buffersink = avfilter_get_by_name("buffersink");
     ret = avfilter_graph_create_filter(buffersink_ctx, buffersink, "out", NULL, NULL, graph);
     if (ret < 0) {
         logger()->error("Cannot create buffer sink.");

src/libvideo2x.cpp

@@ -36,7 +36,7 @@ int VideoProcessor::process(
     int ret = 0;
 
     // Helper lambda to handle errors:
-    auto handle_error = [&](int error_code, const std::string &msg) {
+    auto handle_error = [&](int error_code, const std::string& msg) {
         // Format and log the error message
         char errbuf[AV_ERROR_MAX_STRING_SIZE];
         av_strerror(error_code, errbuf, sizeof(errbuf));
@@ -57,7 +57,7 @@ int VideoProcessor::process(
 
     // Initialize hardware device context
     if (hw_device_type_ != AV_HWDEVICE_TYPE_NONE) {
-        AVBufferRef *tmp_hw_ctx = nullptr;
+        AVBufferRef* tmp_hw_ctx = nullptr;
         ret = av_hwdevice_ctx_create(&tmp_hw_ctx, hw_device_type_, NULL, NULL, 0);
         if (ret < 0) {
             return handle_error(ret, "Error initializing hardware device context");
@@ -72,8 +72,8 @@ int VideoProcessor::process(
         return handle_error(ret, "Failed to initialize decoder");
     }
 
-    AVFormatContext *ifmt_ctx = decoder.get_format_context();
+    AVFormatContext* ifmt_ctx = decoder.get_format_context();
-    AVCodecContext *dec_ctx = decoder.get_codec_context();
+    AVCodecContext* dec_ctx = decoder.get_codec_context();
     int in_vstream_idx = decoder.get_video_stream_index();
 
     // Create and initialize the appropriate filter
@@ -140,19 +140,19 @@ int VideoProcessor::process(
 
 // Process frames using the selected filter.
 int VideoProcessor::process_frames(
-    decoder::Decoder &decoder,
+    decoder::Decoder& decoder,
-    encoder::Encoder &encoder,
+    encoder::Encoder& encoder,
-    std::unique_ptr<processors::Processor> &processor
+    std::unique_ptr<processors::Processor>& processor
 ) {
     char errbuf[AV_ERROR_MAX_STRING_SIZE];
     int ret = 0;
 
     // Get required objects
-    AVFormatContext *ifmt_ctx = decoder.get_format_context();
+    AVFormatContext* ifmt_ctx = decoder.get_format_context();
-    AVCodecContext *dec_ctx = decoder.get_codec_context();
+    AVCodecContext* dec_ctx = decoder.get_codec_context();
     int in_vstream_idx = decoder.get_video_stream_index();
-    AVFormatContext *ofmt_ctx = encoder.get_format_context();
+    AVFormatContext* ofmt_ctx = encoder.get_format_context();
-    int *stream_map = encoder.get_stream_map();
+    int* stream_map = encoder.get_stream_map();
 
     // Reference to the previous frame does not require allocation
     // It will be cloned from the current frame
@@ -236,7 +236,7 @@ int VideoProcessor::process_frames(
                 }
 
                 // Process the frame based on the selected processing mode
-                AVFrame *proc_frame = nullptr;
+                AVFrame* proc_frame = nullptr;
                 switch (processor->get_processing_mode()) {
                     case processors::ProcessingMode::Filter: {
                         ret = process_filtering(processor, encoder, frame.get(), proc_frame);
@@ -269,7 +269,7 @@ int VideoProcessor::process_frames(
     }
 
     // Flush the filter
-    std::vector<AVFrame *> raw_flushed_frames;
+    std::vector<AVFrame*> raw_flushed_frames;
     ret = processor->flush(raw_flushed_frames);
     if (ret < 0) {
         av_strerror(ret, errbuf, sizeof(errbuf));
@@ -279,12 +279,12 @@ int VideoProcessor::process_frames(
 
     // Wrap flushed frames in unique_ptrs
     std::vector<std::unique_ptr<AVFrame, decltype(&avutils::av_frame_deleter)>> flushed_frames;
-    for (AVFrame *raw_frame : raw_flushed_frames) {
+    for (AVFrame* raw_frame : raw_flushed_frames) {
         flushed_frames.emplace_back(raw_frame, &avutils::av_frame_deleter);
     }
 
     // Encode and write all flushed frames
-    for (auto &flushed_frame : flushed_frames) {
+    for (auto& flushed_frame : flushed_frames) {
         ret = write_frame(flushed_frame.get(), encoder);
         if (ret < 0) {
             return ret;
@@ -303,7 +303,7 @@ int VideoProcessor::process_frames(
     return ret;
 }
 
-int VideoProcessor::write_frame(AVFrame *frame, encoder::Encoder &encoder) {
+int VideoProcessor::write_frame(AVFrame* frame, encoder::Encoder& encoder) {
     char errbuf[AV_ERROR_MAX_STRING_SIZE];
     int ret = 0;
 
@@ -318,17 +318,17 @@ int VideoProcessor::write_frame(AVFrame *frame, encoder::Encoder &encoder) {
 }
 
 int VideoProcessor::write_raw_packet(
-    AVPacket *packet,
+    AVPacket* packet,
-    AVFormatContext *ifmt_ctx,
+    AVFormatContext* ifmt_ctx,
-    AVFormatContext *ofmt_ctx,
+    AVFormatContext* ofmt_ctx,
-    int *stream_map
+    int* stream_map
 ) {
     char errbuf[AV_ERROR_MAX_STRING_SIZE];
     int ret = 0;
 
-    AVStream *in_stream = ifmt_ctx->streams[packet->stream_index];
+    AVStream* in_stream = ifmt_ctx->streams[packet->stream_index];
     int out_stream_idx = stream_map[packet->stream_index];
-    AVStream *out_stream = ofmt_ctx->streams[out_stream_idx];
+    AVStream* out_stream = ofmt_ctx->streams[out_stream_idx];
 
     av_packet_rescale_ts(packet, in_stream->time_base, out_stream->time_base);
     packet->stream_index = out_stream_idx;
@@ -342,16 +342,16 @@ int VideoProcessor::write_raw_packet(
 }
 
 int VideoProcessor::process_filtering(
-    std::unique_ptr<processors::Processor> &processor,
+    std::unique_ptr<processors::Processor>& processor,
-    encoder::Encoder &encoder,
+    encoder::Encoder& encoder,
-    AVFrame *frame,
+    AVFrame* frame,
-    AVFrame *proc_frame
+    AVFrame* proc_frame
 ) {
     char errbuf[AV_ERROR_MAX_STRING_SIZE];
     int ret = 0;
 
     // Cast the processor to a Filter
-    processors::Filter *filter = static_cast<processors::Filter *>(processor.get());
+    processors::Filter* filter = static_cast<processors::Filter*>(processor.get());
 
     // Process the frame using the filter
     ret = filter->filter(frame, &proc_frame);
@@ -370,18 +370,18 @@ int VideoProcessor::process_filtering(
 }
 
 int VideoProcessor::process_interpolation(
-    std::unique_ptr<processors::Processor> &processor,
+    std::unique_ptr<processors::Processor>& processor,
-    encoder::Encoder &encoder,
+    encoder::Encoder& encoder,
-    std::unique_ptr<AVFrame, decltype(&avutils::av_frame_deleter)> &prev_frame,
+    std::unique_ptr<AVFrame, decltype(&avutils::av_frame_deleter)>& prev_frame,
-    AVFrame *frame,
+    AVFrame* frame,
-    AVFrame *proc_frame
+    AVFrame* proc_frame
 ) {
     char errbuf[AV_ERROR_MAX_STRING_SIZE];
     int ret = 0;
 
     // Cast the processor to an Interpolator
-    processors::Interpolator *interpolator =
+    processors::Interpolator* interpolator =
-        static_cast<processors::Interpolator *>(processor.get());
+        static_cast<processors::Interpolator*>(processor.get());
 
     // Calculate the time step for each frame
     float time_step = 1.0f / static_cast<float>(proc_cfg_.frm_rate_mul);

src/logger_manager.cpp

@@ -26,7 +26,7 @@ static spdlog::level::level_enum ffmpeg_level_to_spdlog(int av_level) {
     }
 }
 
-static void ffmpeg_log_callback(void *avcl, int level, const char *fmt, va_list vargs) {
+static void ffmpeg_log_callback(void* avcl, int level, const char* fmt, va_list vargs) {
     // Format the message the same way as the default callback
     char line[1024];
     int print_prefix = 1;
@@ -53,7 +53,7 @@ LoggerManager::LoggerManager() {
     spdlog::register_logger(logger_);
 }
 
-LoggerManager &LoggerManager::instance() {
+LoggerManager& LoggerManager::instance() {
     static LoggerManager instance;
     return instance;
 }
@@ -63,9 +63,9 @@ std::shared_ptr<spdlog::logger> LoggerManager::logger() {
 }
 
 bool LoggerManager::reconfigure_logger(
-    const std::string &logger_name,
+    const std::string& logger_name,
-    const std::vector<spdlog::sink_ptr> &sinks,
+    const std::vector<spdlog::sink_ptr>& sinks,
-    const std::string &pattern
+    const std::string& pattern
 ) {
     if (logger_name.empty() || sinks.empty()) {
         return false;
@@ -94,7 +94,7 @@ bool LoggerManager::reconfigure_logger(
     return true;
 }
 
-bool LoggerManager::set_log_level(const std::string &level_str) {
+bool LoggerManager::set_log_level(const std::string& level_str) {
     spdlog::level::level_enum log_level = spdlog::level::from_str(level_str);
     if (log_level == spdlog::level::off && level_str != "off") {
         // Invalid level_str

src/processor_factory.cpp

@@ -13,7 +13,7 @@ namespace video2x {
 namespace processors {
 
 // Access the singleton instance
-ProcessorFactory &ProcessorFactory::instance() {
+ProcessorFactory& ProcessorFactory::instance() {
     static ProcessorFactory factory;
 
     // Ensure default processors are registered only once
@@ -33,7 +33,7 @@ void ProcessorFactory::register_processor(ProcessorType type, Creator creator) {
 
 // Create a processor instance
 std::unique_ptr<Processor> ProcessorFactory::create_processor(
-    const ProcessorConfig &proc_cfg,
+    const ProcessorConfig& proc_cfg,
     uint32_t vk_device_index
 ) const {
     auto it = creators.find(proc_cfg.processor_type);
@@ -49,12 +49,12 @@ std::unique_ptr<Processor> ProcessorFactory::create_processor(
 }
 
 // Initialize default processors
-void ProcessorFactory::init_default_processors(ProcessorFactory &factory) {
+void ProcessorFactory::init_default_processors(ProcessorFactory& factory) {
     factory.register_processor(
         ProcessorType::Libplacebo,
-        [](const ProcessorConfig &proc_cfg,
+        [](const ProcessorConfig& proc_cfg,
            uint32_t vk_device_index) -> std::unique_ptr<Processor> {
-            const auto &config = std::get<LibplaceboConfig>(proc_cfg.config);
+            const auto& config = std::get<LibplaceboConfig>(proc_cfg.config);
             if (config.shader_path.empty()) {
                 logger()->critical("Shader path must be provided for the libplacebo filter");
                 return nullptr;
@@ -76,9 +76,9 @@ void ProcessorFactory::init_default_processors(ProcessorFactory &factory) {
 
     factory.register_processor(
         ProcessorType::RealESRGAN,
-        [](const ProcessorConfig &proc_cfg,
+        [](const ProcessorConfig& proc_cfg,
            uint32_t vk_device_index) -> std::unique_ptr<Processor> {
-            const auto &config = std::get<RealESRGANConfig>(proc_cfg.config);
+            const auto& config = std::get<RealESRGANConfig>(proc_cfg.config);
             if (proc_cfg.scaling_factor <= 0) {
                 logger()->critical("Scaling factor must be provided for the RealESRGAN filter");
                 return nullptr;
@@ -98,9 +98,9 @@ void ProcessorFactory::init_default_processors(ProcessorFactory &factory) {
 
     factory.register_processor(
         ProcessorType::RealCUGAN,
-        [](const ProcessorConfig &proc_cfg,
+        [](const ProcessorConfig& proc_cfg,
            uint32_t vk_device_index) -> std::unique_ptr<Processor> {
-            const auto &config = std::get<RealCUGANConfig>(proc_cfg.config);
+            const auto& config = std::get<RealCUGANConfig>(proc_cfg.config);
             if (proc_cfg.scaling_factor <= 0) {
                 logger()->critical("Scaling factor must be provided for the RealCUGAN filter");
                 return nullptr;
@@ -123,9 +123,9 @@ void ProcessorFactory::init_default_processors(ProcessorFactory &factory) {
 
     factory.register_processor(
         ProcessorType::RIFE,
-        [](const ProcessorConfig &proc_cfg,
+        [](const ProcessorConfig& proc_cfg,
            uint32_t vk_device_index) -> std::unique_ptr<Processor> {
-            const auto &cfg = std::get<RIFEConfig>(proc_cfg.config);
+            const auto& cfg = std::get<RIFEConfig>(proc_cfg.config);
             if (cfg.model_name.empty()) {
                 logger()->critical("Model name must be provided for the RIFE filter");
                 return nullptr;