mxwrite.hpp File Reference

FFmpeg-based video writer used by MXWrite. More...

#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavutil/hwcontext.h>
#include <libavutil/imgutils.h>
#include <libavutil/mathematics.h>
#include <libavutil/opt.h>
#include <libswscale/swscale.h>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <cstdint>
#include <mutex>
#include <queue>
#include <string>
#include <string_view>
#include <thread>
#include <vector>

Go to the source code of this file.

Classes
struct	EncodeOptions
	User-configurable video encoder quality options. More...
struct	EncoderInfo
	A video encoder reported by the linked FFmpeg installation. More...
struct	EncoderOptionInfo
	One configurable AVOption exposed by a video encoder. More...
struct	Frame_Data
	Queue entry that stores a frame pointer and its capture timestamp. More...
struct	EncodeOptions::HdrInfo
	HDR output options. More...
class	Writer
	FFmpeg-backed RGBA video writer. More...

Functions
std::vector< EncoderInfo >	available_video_encoders ()
void	cleanup_contexts (AVFormatContext *source_ctx, AVFormatContext *dest_ctx, AVFormatContext *output_ctx)
	Free FFmpeg format contexts used during transfer operations.
void	transfer_audio (std::string_view sourceAudioFile, std::string_view destVideoFile)
	Copy audio from one video file to another.
std::vector< EncoderOptionInfo >	video_encoder_options (std::string_view encoder_name)
	Return the options exposed by one registered video encoder.

Detailed Description

FFmpeg-based video writer used by MXWrite.

Definition in file mxwrite.hpp.

Function Documentation

available_video_encoders()

std::vector< EncoderInfo > available_video_encoders

(

)

Returns

Video encoders registered by the linked FFmpeg libraries.

Definition at line 980 of file mxwrite.cpp.

                                                  {
    std::vector<EncoderInfo> result;
    void *iterator = nullptr;
    while (const AVCodec *codec = av_codec_iterate(&iterator)) {
        if (!av_codec_is_encoder(codec) || codec->type != AVMEDIA_TYPE_VIDEO || !codec->name) {
            continue;
        }
        EncoderInfo info;
        info.name = codec->name;
        info.long_name = codec->long_name ? codec->long_name : codec->name;
        info.codec_name = avcodec_get_name(codec->id);
        info.hardware = codec_uses_hardware(codec);
        info.experimental = (codec->capabilities & AV_CODEC_CAP_EXPERIMENTAL) != 0;
        const std::vector<AVPixelFormat> formats = supported_pixel_formats(codec);
        for (AVPixelFormat format : formats) {
            const char *name = av_get_pix_fmt_name(format);
            if (!name) {
                continue;
            }
            if (!info.pixel_formats.empty()) {
                info.pixel_formats += ", ";
            }
            info.pixel_formats += name;
        }
        result.push_back(std::move(info));
    }
    std::sort(result.begin(), result.end(), [](const EncoderInfo &left, const EncoderInfo &right) {
        if (left.codec_name != right.codec_name) {
            return left.codec_name < right.codec_name;
        }
        if (left.hardware != right.hardware) {
            return left.hardware > right.hardware;
        }
        return left.name < right.name;
    });
    return result;
}

cleanup_contexts()

void cleanup_contexts ( AVFormatContext * source_ctx, AVFormatContext * dest_ctx, AVFormatContext * output_ctx )

extern

Free FFmpeg format contexts used during transfer operations.

Parameters

source_ctx	Source format context.
dest_ctx	Destination format context.
output_ctx	Output format context.

Definition at line 226 of file mxwrite.cpp.

                                                   {
    if (source_ctx)
        avformat_close_input(&source_ctx);
    if (dest_ctx)
        avformat_close_input(&dest_ctx);
    if (output_ctx) {
        if (!(output_ctx->oformat->flags & AVFMT_NOFILE))
            avio_closep(&output_ctx->pb);
        avformat_free_context(output_ctx);
    }
}

transfer_audio()

void transfer_audio ( std::string_view sourceAudioFile, std::string_view destVideoFile )

extern

Copy audio from one video file to another.

Parameters

sourceAudioFile	Input media file containing the audio stream.
destVideoFile	Output video file to receive the audio stream.

Definition at line 240 of file mxwrite.cpp.

                                                                                  {
    std::lock_guard<std::mutex> lock(transfer_audio_mutex);
    if (!is_format_supported(destVideoFile.data())) {
        std::cerr << "Unsupported output format. Supported formats: .mp4, .mkv, .avi, .mov\n";
        return;
    }
 
    AVFormatContext *source_ctx = nullptr, *dest_ctx = nullptr, *output_ctx = nullptr;
    int source_audio_idx = -1, dest_video_idx = -1, dest_audio_idx = -1;
    std::string temp_output = std::string(destVideoFile) + ".tmp";
 
    if (avformat_open_input(&source_ctx, sourceAudioFile.data(), nullptr, nullptr) != 0 ||
        avformat_open_input(&dest_ctx, destVideoFile.data(), nullptr, nullptr) != 0) {
        std::cerr << "Failed to open input files\n";
        cleanup_contexts(source_ctx, dest_ctx, output_ctx);
        return;
    }
 
    if (avformat_find_stream_info(source_ctx, nullptr) < 0 ||
        avformat_find_stream_info(dest_ctx, nullptr) < 0) {
        std::cerr << "Failed to find stream info\n";
        cleanup_contexts(source_ctx, dest_ctx, output_ctx);
        return;
    }
 
    for (unsigned i = 0; i < source_ctx->nb_streams; ++i) {
        if (source_ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
            source_audio_idx = i;
            break;
        }
    }
 
    for (unsigned i = 0; i < dest_ctx->nb_streams; ++i) {
        AVMediaType type = dest_ctx->streams[i]->codecpar->codec_type;
        if (type == AVMEDIA_TYPE_VIDEO)
            dest_video_idx = i;
        else if (type == AVMEDIA_TYPE_AUDIO)
            dest_audio_idx = i;
    }
 
    if (source_audio_idx == -1 || dest_video_idx == -1) {
        std::cerr << "Required streams not found\n";
        cleanup_contexts(source_ctx, dest_ctx, output_ctx);
        return;
    }
 
    const AVOutputFormat *output_fmt = av_guess_format(nullptr, destVideoFile.data(), nullptr);
    if (!output_fmt) {
        output_fmt = av_guess_format("mp4", nullptr, nullptr);
        if (!output_fmt) {
            std::cerr << "Failed to determine output format\n";
            cleanup_contexts(source_ctx, dest_ctx, output_ctx);
            return;
        }
    }
 
    if (avformat_alloc_output_context2(&output_ctx, output_fmt, nullptr, temp_output.c_str()) < 0) {
        std::cerr << "Failed to create output context\n";
        cleanup_contexts(source_ctx, dest_ctx, output_ctx);
        return;
    }
 
    const AVCodec *audio_codec = avcodec_find_decoder(source_ctx->streams[source_audio_idx]->codecpar->codec_id);
    if (!audio_codec) {
        std::cerr << "Failed to find audio decoder\n";
        cleanup_contexts(source_ctx, dest_ctx, output_ctx);
        return;
    }
 
    for (unsigned i = 0; i < dest_ctx->nb_streams; ++i) {
        if (dest_ctx->streams[i]->codecpar->codec_type != AVMEDIA_TYPE_VIDEO) {
            continue;
        }
 
        AVStream *dest_stream = dest_ctx->streams[i];
        AVStream *out_stream = avformat_new_stream(output_ctx, nullptr);
        if (!out_stream) {
            std::cerr << "Failed to create output stream\n";
            cleanup_contexts(source_ctx, dest_ctx, output_ctx);
            return;
        }
 
        if (avcodec_parameters_copy(out_stream->codecpar, dest_stream->codecpar) < 0) {
            std::cerr << "Failed to copy video parameters\n";
            cleanup_contexts(source_ctx, dest_ctx, output_ctx);
            return;
        }
 
        out_stream->time_base = dest_stream->time_base;
        out_stream->codecpar->codec_tag = 0;
    }
 
    AVStream *out_stream = avformat_new_stream(output_ctx, audio_codec);
    if (!out_stream) {
        std::cerr << "Failed to create audio stream\n";
        cleanup_contexts(source_ctx, dest_ctx, output_ctx);
        return;
    }
 
    AVCodecParameters *source_params = source_ctx->streams[source_audio_idx]->codecpar;
    if (avcodec_parameters_copy(out_stream->codecpar, source_params) < 0) {
        std::cerr << "Failed to copy audio parameters\n";
        cleanup_contexts(source_ctx, dest_ctx, output_ctx);
        return;
    }
 
    if (source_params->frame_size == 0) {
        out_stream->codecpar->frame_size = 1024;
    } else {
        out_stream->codecpar->frame_size = source_params->frame_size;
    }
 
    out_stream->time_base = source_ctx->streams[source_audio_idx]->time_base;
    out_stream->codecpar->codec_tag = 0;
    dest_audio_idx = out_stream->index;
 
    if (!(output_ctx->oformat->flags & AVFMT_NOFILE)) {
        if (avio_open(&output_ctx->pb, temp_output.c_str(), AVIO_FLAG_WRITE) < 0) {
            std::cerr << "Failed to open output file\n";
            cleanup_contexts(source_ctx, dest_ctx, output_ctx);
            return;
        }
    }
    if (avformat_write_header(output_ctx, nullptr) < 0) {
        std::cerr << "Failed to write header\n";
        cleanup_contexts(source_ctx, dest_ctx, output_ctx);
        return;
    }
    AVPacket packet;
    while (av_read_frame(dest_ctx, &packet) >= 0) {
        if (packet.stream_index == dest_audio_idx) {
            av_packet_unref(&packet);
            continue;
        }
 
        AVStream *in_stream = dest_ctx->streams[packet.stream_index];
        AVStream *out_stream = output_ctx->streams[packet.stream_index];
        av_packet_rescale_ts(&packet, in_stream->time_base, out_stream->time_base);
 
        if (av_interleaved_write_frame(output_ctx, &packet) < 0) {
            std::cerr << "Failed to write packet\n";
            av_packet_unref(&packet);
            cleanup_contexts(source_ctx, dest_ctx, output_ctx);
            return;
        }
        av_packet_unref(&packet);
    }
 
    int64_t video_duration_ts = 0;
    {
        AVStream *vid_stream = dest_ctx->streams[0];
        if (vid_stream->duration > 0) {
            video_duration_ts = av_rescale_q(vid_stream->duration, vid_stream->time_base, source_ctx->streams[source_audio_idx]->time_base);
        } else if (dest_ctx->duration > 0) {
            AVRational av_tb = {1, AV_TIME_BASE};
            video_duration_ts = av_rescale_q(dest_ctx->duration, av_tb, source_ctx->streams[source_audio_idx]->time_base);
        }
    }
 
    av_seek_frame(source_ctx, source_audio_idx, 0, AVSEEK_FLAG_BACKWARD);
    while (av_read_frame(source_ctx, &packet) >= 0) {
        if (packet.stream_index == source_audio_idx) {
            if (video_duration_ts > 0 && packet.pts != AV_NOPTS_VALUE && packet.pts > video_duration_ts) {
                av_packet_unref(&packet);
                break;
            }
            AVStream *in_stream = source_ctx->streams[packet.stream_index];
            AVStream *out_stream = output_ctx->streams[dest_audio_idx];
            av_packet_rescale_ts(&packet, in_stream->time_base, out_stream->time_base);
            packet.stream_index = dest_audio_idx;
 
            if (av_interleaved_write_frame(output_ctx, &packet) < 0) {
                std::cerr << "Failed to write audio packet\n";
                av_packet_unref(&packet);
                cleanup_contexts(source_ctx, dest_ctx, output_ctx);
                return;
            }
        }
        av_packet_unref(&packet);
    }
    av_write_trailer(output_ctx);
    cleanup_contexts(source_ctx, dest_ctx, output_ctx);
    std::remove(destVideoFile.data());
    std::rename(temp_output.c_str(), destVideoFile.data());
}

video_encoder_options()

std::vector< EncoderOptionInfo > video_encoder_options

(

std::string_view

encoder_name

)

Return the options exposed by one registered video encoder.

Parameters

encoder_name

Exact encoder name returned by available_video_encoders().

Definition at line 1018 of file mxwrite.cpp.

                                                                                {
    const std::string name(encoder_name);
    const AVCodec *codec = avcodec_find_encoder_by_name(name.c_str());
    if (!codec || codec->type != AVMEDIA_TYPE_VIDEO) {
        return {};
    }
    AVCodecContext *context = avcodec_alloc_context3(codec);
    if (!context) {
        return {};
    }
    std::vector<EncoderOptionInfo> result;
    std::set<std::string> seen;
    append_encoder_options(context->priv_data, result, seen);
    append_encoder_options(context, result, seen);
    avcodec_free_context(&context);
    std::sort(result.begin(), result.end(), [](const EncoderOptionInfo &left, const EncoderOptionInfo &right) {
        return left.name < right.name;
    });
    return result;
}