enable choosing of system codecs when encoding video

[hn-88]

Currently, there is not much choice - we can only choose the fourcc, and the video encoding is done via OpenCV's internal ffmpeg code (or so I think.) If we can figure out a way to use external ffmpeg, then we might be able to use parameters like -c:v h264_nvenc - and then by giving suitable parameters, we could solve issue #25 also, -framerate 30 for example, https://video.stackexchange.com/questions/19754/changing-the-input-frame-rate-of-a-series-of-images-in-ffmpeg

[hn-88]

Apparently CUDA accelerated codecs like NVENC can be used by enabling CUDA support in OpenCV?
https://docs.opencv.org/4.11.0/d0/d61/group__cudacodec.html

[hn-88]

Example of CUDA codec video writing - https://github.com/opencv/opencv/blob/master/samples/gpu/video_writer.cpp

An #if defined block could enable support for non-cuda also.

[hn-88]

And - "Since OpenCV 4.5.2 new properties are added to control H/W acceleration modes for video decoding and encoding tasks. New builtin properties brings easy to use API for OpenCV Users." https://github.com/opencv/opencv/wiki/Video-IO-hardware-acceleration#introduction

[hn-88]

Need to enable the features, using environment variables - https://docs.opencv.org/4.x/d6/dea/tutorial_env_reference.html via opencv/opencv#21155

[hn-88]

And we can get all the codecs via ffmpeg - https://write.corbpie.com/ffmpeg-list-all-codecs-encoders-decoders-and-formats/

That blog seems to have a wealth of info on ffmpeg

[hn-88]

Avidemux source is at https://github.com/mean00/avidemux2/

We can look at how the "Video Output" dropdown box is populated with the available codecs. Starting with 'Copy' codec, etc.

[hn-88]

As suggested by copilot -

#include <opencv2/opencv.hpp>
#include <opencv2/cudacodec.hpp>
#include <opencv2/cudaimgproc.hpp>
#include <opencv2/cudaoptflow.hpp>
#include <iostream>
#include <string>

using namespace cv;

int main(int argc, char** argv) {
    // Check if CUDA is available
    bool use_cuda = cv::cuda::getCudaEnabledDeviceCount() > 0;
    if (use_cuda) {
        cv::cuda::setDevice(0);
        cv::cuda::printShortCudaDeviceInfo(cv::cuda::getDevice());
    } else {
        std::cerr << "CUDA is not available. Falling back to CPU-based processing." << std::endl;
    }

    // Input and output paths
    if (argc < 3) {
        std::cerr << "Usage: " << argv[0] << " <input_video> <output_video>" << std::endl;
        return -1;
    }
    std::string inputPath = argv[1];
    std::string outputPath = argv[2];

    // Open input video
    VideoCapture inputVideo(inputPath);
    if (!inputVideo.isOpened()) {
        std::cerr << "Error: Could not open input video: " << inputPath << std::endl;
        return -1;
    }

    // Get input video properties
    Size frameSize = Size((int)inputVideo.get(CAP_PROP_FRAME_WIDTH), (int)inputVideo.get(CAP_PROP_FRAME_HEIGHT));
    double fps = inputVideo.get(CAP_PROP_FPS);

    // Declare GPU and CPU VideoWriter objects
    cv::Ptr<cv::cudacodec::VideoWriter> d_writer;
    cv::VideoWriter cpu_writer;

    // CUDA Stream for GPU processing
    cv::cuda::Stream stream;

    // Initialize VideoWriter based on CUDA availability
    if (use_cuda) {
        std::cout << "Initializing CUDA VideoWriter..." << std::endl;

        // Use CUDA VideoWriter for H.264 encoding
        d_writer = cv::cudacodec::createVideoWriter(
            outputPath,              // Output file
            frameSize,               // Frame size
            cv::cudacodec::Codec::H264, // Codec
            fps,                     // Frames per second
            cv::cudacodec::ColorFormat::BGR, // Input color format
            0,                       // Additional options
            stream                   // CUDA Stream
        );
    } else {
        std::cout << "Using CPU VideoWriter as fallback..." << std::endl;

        // Use CPU VideoWriter with user-defined codec
        int codec = VideoWriter::fourcc('X', 'V', 'I', 'D'); // Example codec
        cpu_writer.open(outputPath, codec, fps, frameSize, true);

        if (!cpu_writer.isOpened()) {
            std::cerr << "Error: Could not initialize CPU VideoWriter." << std::endl;
            return -1;
        }
    }

    // Process and write video frames
    Mat frame;
    cv::cuda::GpuMat d_frame;
    for (;;) {
        inputVideo >> frame; // Read frame
        if (frame.empty()) break; // End of video

        if (use_cuda && !d_writer.empty()) {
            // Upload frame to GPU
            d_frame.upload(frame, stream);

            // Write frame using CUDA VideoWriter
            d_writer->write(d_frame);
        } else {
            // Write frame using CPU VideoWriter
            cpu_writer.write(frame);
        }
    }

    std::cout << "Video processing and writing complete!" << std::endl;
    return 0;
}

[hn-88]

To query the actual supported codecs using FFMPEG's codec enumeration, you can use the FFMPEG libraries (libavcodec, libavformat, and libavutil). Below is a code snippet to enumerate the available codecs and display them.

Code Snippet: Enumerating Supported Codecs with FFMPEG

extern "C" {
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavutil/avutil.h>
}

#include <iostream>

void listSupportedCodecs() {
    // Initialize FFMPEG
    avcodec_register_all();

    std::cout << "Supported Codecs:" << std::endl;

    // Iterate through all registered codecs
    const AVCodec* codec = nullptr;
    void* iterator = nullptr;

    while ((codec = av_codec_iterate(&iterator))) {
        std::string codecType;

        // Determine the codec type
        if (codec->type == AVMEDIA_TYPE_VIDEO) {
            codecType = "Video";
        } else if (codec->type == AVMEDIA_TYPE_AUDIO) {
            codecType = "Audio";
        } else {
            codecType = "Other";
        }

        // Print codec information
        std::cout << "- " << codec->name
                  << " (" << codec->long_name << ")"
                  << " [Type: " << codecType << "]"
                  << (av_codec_is_encoder(codec) ? " [Encoder]" : "")
                  << (av_codec_is_decoder(codec) ? " [Decoder]" : "")
                  << std::endl;
    }
}

int main() {
    // List all supported codecs
    listSupportedCodecs();
    return 0;
}

Key Points in the Code

1. FFMPEG Initialization:

   • avcodec_register_all() ensures all codecs are registered.
   • av_codec_iterate iterates through all registered codecs.

2. Codec Type Identification:

   • Checks if a codec is for video, audio, or other media types using codec->type.

3. Encoder/Decoder Detection:

   • Uses av_codec_is_encoder and av_codec_is_decoder to check if a codec supports encoding or decoding.

4. Printing Codec Info:

   • Prints the codec name (codec->name), long name (codec->long_name), type, and whether it is an encoder or decoder.

Build Instructions

To compile this program, you need to have FFMPEG development libraries installed. Use the following command:

g++ -o list_codecs list_codecs.cpp -lavcodec -lavformat -lavutil

Output Example

When you run the program, it will list all codecs supported by your FFMPEG build. Example output:

Supported Codecs:
- h264 (H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10) [Type: Video] [Encoder] [Decoder]
- aac (AAC (Advanced Audio Coding)) [Type: Audio] [Encoder] [Decoder]
- vp9 (Google VP9) [Type: Video] [Decoder]
- mp3 (MP3 (MPEG audio layer 3)) [Type: Audio] [Decoder]
...

This code can be extended to filter codecs by type (e.g., video-only or audio-only), or to allow user selection for integration into your project. Let me know if you need further assistance!

[hn-88]

The condition codec->type == AVMEDIA_TYPE_VIDEO ensures only video codecs are listed.

extern "C" {
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavutil/avutil.h>
}

#include <iostream>

void listVideoCodecs() {
    // Initialize FFMPEG
    avcodec_register_all();

    std::cout << "Supported Video Codecs:" << std::endl;

    // Iterate through all registered codecs
    const AVCodec* codec = nullptr;
    void* iterator = nullptr;

    while ((codec = av_codec_iterate(&iterator))) {
        // Filter for video codecs only
        if (codec->type == AVMEDIA_TYPE_VIDEO) {
            std::cout << "- " << codec->name
                      << " (" << codec->long_name << ")"
                      << (av_codec_is_encoder(codec) ? " [Encoder]" : "")
                      << (av_codec_is_decoder(codec) ? " [Decoder]" : "")
                      << std::endl;
        }
    }
}

int main() {
    // List all supported video codecs
    listVideoCodecs();
    return 0;
}

[hn-88]

Example for linking / cmake file etc is at https://medium.com/@restlessladder/real-time-h-265-video-stream-encoding-with-c-and-libavcodec-77eafc20fa9e

[hn-88]

https://github.com/hn-88/test-ffmpeg-codec-listing

./test*mage | grep Video | grep Encoder | wc -l
118

[hn-88]

118 elements in a drop-down list would be unwieldy. Need to choose only a subset.

[hn-88]

https://github.com/opencv/opencv/blob/master/modules/videoio/src/ffmpeg_codecs.hpp
this lists ffmpeg codecs which can be chosen for videowriter, I guess, but doesn't mention nvenc etc.

[hn-88]

opencv/opencv_contrib#2560
seems to indicate we have to build opencv with cuda enabled?