mxwrite.cpp File Reference

#include "mxwrite.hpp"
#include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <set>
#include <sstream>
#include <string>
#include <thread>
#include <utility>
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavutil/imgutils.h>
#include <libavutil/mastering_display_metadata.h>
#include <libavutil/mathematics.h>
#include <libavutil/opt.h>
#include <libavutil/pixdesc.h>
#include <libswscale/swscale.h>

Go to the source code of this file.

Classes
struct	anonymous_namespace{mxwrite.cpp}::FfmpegOption

Namespaces
namespace	anonymous_namespace{mxwrite.cpp}

Functions
void	anonymous_namespace{mxwrite.cpp}::append_encoder_options (void *object, std::vector< EncoderOptionInfo > &result, std::set< std::string > &seen)
bool	anonymous_namespace{mxwrite.cpp}::apply_ffmpeg_options (const std::vector< FfmpegOption > &options, AVCodecContext *context, AVFormatContext *output_context)
std::vector< EncoderInfo >	available_video_encoders ()
AVPixelFormat	anonymous_namespace{mxwrite.cpp}::choose_software_pixel_format (const AVCodec *codec, AVPixelFormat requested_format)
uint16_t	anonymous_namespace{mxwrite.cpp}::clamp10 (float v)
void	cleanup_contexts (AVFormatContext *source_ctx, AVFormatContext *dest_ctx, AVFormatContext *output_ctx)
	Free FFmpeg format contexts used during transfer operations.
bool	anonymous_namespace{mxwrite.cpp}::codec_uses_hardware (const AVCodec *codec)
void	anonymous_namespace{mxwrite.cpp}::convertBt2020Rgba16EncodedToYuv420p10 (const uint16_t *rgba, int src_stride_shorts, uint16_t *y_plane, int y_stride_shorts, uint16_t *u_plane, int u_stride_shorts, uint16_t *v_plane, int v_stride_shorts, int width, int height)
void	anonymous_namespace{mxwrite.cpp}::convertRgbaToBt2020PqYuv420p10 (const uint8_t *rgba, int src_stride_bytes, uint16_t *y_plane, int y_stride_shorts, uint16_t *u_plane, int u_stride_shorts, uint16_t *v_plane, int v_stride_shorts, int width, int height)
const std::string *	anonymous_namespace{mxwrite.cpp}::find_ffmpeg_option (const std::vector< FfmpegOption > &options, const std::string &name)
bool	anonymous_namespace{mxwrite.cpp}::is_codec_name (const std::string &value)
bool	is_format_supported (const char *filename)
bool	anonymous_namespace{mxwrite.cpp}::is_hardware_pixel_format (AVPixelFormat format)
bool	anonymous_namespace{mxwrite.cpp}::is_nvenc_tune (const std::string &tune)
bool	anonymous_namespace{mxwrite.cpp}::is_reserved_ffmpeg_option (const std::string &name)
bool	anonymous_namespace{mxwrite.cpp}::is_valid_x264_preset (const std::string &p)
bool	anonymous_namespace{mxwrite.cpp}::looks_like_option (const std::string &token)
std::string	anonymous_namespace{mxwrite.cpp}::lowercase_ascii (std::string text)
std::string	anonymous_namespace{mxwrite.cpp}::normalize_ffmpeg_option_name (std::string name)
std::string	anonymous_namespace{mxwrite.cpp}::number_text (double value)
std::string	anonymous_namespace{mxwrite.cpp}::nvenc_preset_to_software (const std::string &preset)
int	anonymous_namespace{mxwrite.cpp}::option_base_type (AVOptionType type)
bool	anonymous_namespace{mxwrite.cpp}::option_has_numeric_range (AVOptionType type)
std::string	anonymous_namespace{mxwrite.cpp}::option_type_name (AVOptionType type)
bool	anonymous_namespace{mxwrite.cpp}::parse_ffmpeg_options (const std::string &text, std::vector< FfmpegOption > &options)
float	anonymous_namespace{mxwrite.cpp}::pqOetf (float L)
bool	anonymous_namespace{mxwrite.cpp}::set_named_encoder_option (void *object, const char *name, const std::string &value)
std::vector< FfmpegOption >	anonymous_namespace{mxwrite.cpp}::software_fallback_options (const std::vector< FfmpegOption > &options, bool use_hevc_codec)
float	anonymous_namespace{mxwrite.cpp}::srgbEotf (float v)
std::vector< AVPixelFormat >	anonymous_namespace{mxwrite.cpp}::supported_pixel_formats (const AVCodec *codec)
bool	anonymous_namespace{mxwrite.cpp}::tokenize_ffmpeg_options (const std::string &text, std::vector< std::string > &tokens, std::string &error)
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.
const char *	anonymous_namespace{mxwrite.cpp}::x264_preset_to_nvenc (const std::string &p)

Variables
constexpr float	anonymous_namespace{mxwrite.cpp}::kPqC1 = 3424.0f / 4096.0f
constexpr float	anonymous_namespace{mxwrite.cpp}::kPqC2 = (2413.0f / 4096.0f) * 32.0f
constexpr float	anonymous_namespace{mxwrite.cpp}::kPqC3 = (2392.0f / 4096.0f) * 32.0f
constexpr float	anonymous_namespace{mxwrite.cpp}::kPqM1 = 2610.0f / 16384.0f
constexpr float	anonymous_namespace{mxwrite.cpp}::kPqM2 = (2523.0f / 4096.0f) * 128.0f
constexpr float	anonymous_namespace{mxwrite.cpp}::kSdrRefFraction = 100.0f / 10000.0f
std::mutex	transfer_audio_mutex

Function Documentation

available_video_encoders()

std::vector< EncoderInfo > available_video_encoders

(

)

Returns

Video encoders registered by the linked FFmpeg libraries.

Definition at line 920 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 )

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 209 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);
    }
}

is_format_supported()

bool is_format_supported

(

const char *

filename

)

Definition at line 194 of file mxwrite.cpp.

                                               {
    const char *ext = strrchr(filename, '.');
    if (!ext)
        return false;
    // Lowercase the extension for case-insensitive comparison.
    std::string lower_ext(ext);
    std::transform(lower_ext.begin(), lower_ext.end(), lower_ext.begin(), [](unsigned char c) { return std::tolower(c); });
    static const char *kSupported[] = {".mp4", ".mkv", ".mov", ".avi", ".m4v", ".ts", ".mts", ".m2ts", ".mpg", ".mpeg", ".flv", ".f4v", ".3gp", ".3g2", ".wmv", ".asf", ".vob"};
    for (const char *s : kSupported) {
        if (lower_ext == s)
            return true;
    }
    return false;
}

transfer_audio()

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

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 221 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 958 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;
}

Variable Documentation

transfer_audio_mutex

std::mutex transfer_audio_mutex

Definition at line 192 of file mxwrite.cpp.