open()

bool MayaFlux::IO::VideoEncodeContext::open	(	FFmpegMuxContext &	mux,
		uint32_t	width,
		uint32_t	height,
		double	frame_rate,
		AVPixelFormat	src_pixel_format,
		AVCodecID	codec_id
	)

Open the encoder and register a video stream in the mux context.

Selects the encoder: if codec_id is AV_CODEC_ID_NONE the container's default video codec is used (MP4/MKV -> H.264, WebM -> VP9, AVI -> MPEG4). Allocates AVCodecContext, initialises SwsContext converting from src_pixel_format to the encoder's required pixel format, allocates the scratch AVFrame, and copies codec parameters to the new AVStream.

Must be called after FFmpegMuxContext::open() and before FFmpegMuxContext::write_header().

Parameters

mux	Open mux context that will own the output stream.
width	Frame width in pixels.
height	Frame height in pixels.
frame_rate	Average frame rate in frames per second.
src_pixel_format	Source AVPixelFormat delivered by the readback thread.
codec_id	Encoder override; AV_CODEC_ID_NONE = container default.

Returns

True on success; false sets the internal error string.

< let encoder decide from crf

Definition at line 106 of file VideoEncodeContext.cpp.

{
    close();
 
    if (!mux.is_open()) {
        m_last_error = "VideoEncodeContext::open: mux context is not open";
        return false;
    }
 
    if (width == 0 || height == 0 || frame_rate <= 0.0) {
        m_last_error = "VideoEncodeContext::open: invalid dimensions or frame rate";
        return false;
    }
 
    m_width = width;
    m_height = height;
    m_src_src_bpp = bpp_for_format(src_pixel_format);
    m_src_pixel_fmt = src_pixel_format;
    m_src_pixel_fmt = src_pixel_format;
 
    if (codec_id == AV_CODEC_ID_NONE)
        codec_id = infer_video_codec(mux.format_context);
 
    const AVCodec* codec = avcodec_find_encoder(codec_id);
    if (!codec) {
        m_last_error = std::string("avcodec_find_encoder failed for codec_id=")
            + std::to_string(static_cast<int>(codec_id));
        return false;
    }
 
    codec_context = avcodec_alloc_context3(codec);
    if (!codec_context) {
        m_last_error = "avcodec_alloc_context3 failed";
        return false;
    }
 
    ///< H.264/H.265 require dimensions divisible by 2
    codec_context->width = static_cast<int>(width % 2 == 0 ? width : width - 1);
    codec_context->height = static_cast<int>(height % 2 == 0 ? height : height - 1);
 
    /*
     * Convert double fps to AVRational. Use millisecond time_base so fractional
     * rates (23.976, 29.97, 59.94) round-trip without drift.
     */
    const int fps_num = static_cast<int>(std::round(frame_rate * 1000.0));
    codec_context->framerate = { .num = fps_num, .den = 1000 };
    codec_context->time_base = { .num = 1000, .den = fps_num };
 
    /*
     * YUV420P is the universally supported pixel format for H.264/H.265.
     * VP9 and MPEG4 also accept it. For codecs that require a different native
     * format, callers must pass an appropriate codec_id and the caller-side
     * src_pixel_format. The sws_scale below handles any conversion.
     */
    codec_context->pix_fmt = AV_PIX_FMT_YUV420P;
 
    /*
     *Reasonable quality defaults — not tunable here; callers set codec options
     * via AVDictionary on codec_context before open() returns if needed.
     */
    codec_context->bit_rate = 0; ///< let encoder decide from crf
    if (codec_id == AV_CODEC_ID_H264 || codec_id == AV_CODEC_ID_H265) {
        av_opt_set(codec_context->priv_data, "preset", "fast", 0);
        av_opt_set(codec_context->priv_data, "crf", "23", 0);
    }
 
    if (mux.format_context->oformat->flags & AVFMT_GLOBALHEADER)
        codec_context->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
 
    if (avcodec_open2(codec_context, codec, nullptr) < 0) {
        m_last_error = "avcodec_open2 failed";
        close();
        return false;
    }
 
    m_stream = mux.add_stream();
    if (!m_stream) {
        m_last_error = "FFmpegMuxContext::add_stream returned nullptr";
        close();
        return false;
    }
 
    if (avcodec_parameters_from_context(m_stream->codecpar, codec_context) < 0) {
        m_last_error = "avcodec_parameters_from_context failed";
        close();
        return false;
    }
 
    m_stream->time_base = codec_context->time_base;
    m_stream_index = m_stream->index;
 
    // -------------------------------------------------------------------------
    // SwsContext: source format -> YUV420P
    // -------------------------------------------------------------------------
    sws_context = sws_getContext(
        codec_context->width,
        codec_context->height,
        src_pixel_format,
        codec_context->width,
        codec_context->height,
        codec_context->pix_fmt,
        SWS_BILINEAR,
        nullptr, nullptr, nullptr);
 
    if (!sws_context) {
        m_last_error = "sws_getContext failed";
        close();
        return false;
    }
 
    // -------------------------------------------------------------------------
    // Scratch frame for sws_scale output
    // -------------------------------------------------------------------------
    m_scratch_frame = av_frame_alloc();
    if (!m_scratch_frame) {
        m_last_error = "av_frame_alloc failed";
        close();
        return false;
    }
 
    m_scratch_frame->format = codec_context->pix_fmt;
    m_scratch_frame->width = codec_context->width;
    m_scratch_frame->height = codec_context->height;
 
    if (av_frame_get_buffer(m_scratch_frame, 32) < 0) {
        m_last_error = "av_frame_get_buffer failed";
        close();
        return false;
    }
 
    MF_INFO(Journal::Component::IO, Journal::Context::FileIO,
        "[VideoEncodeContext] open: {}x{} @ {:.3f} fps | src={} enc={} stream#{}",
        codec_context->width, codec_context->height, frame_rate,
        av_get_pix_fmt_name(src_pixel_format) ? av_get_pix_fmt_name(src_pixel_format) : "unknown",
        avcodec_get_name(codec_id),
        m_stream_index);
 
    return true;
}

References MayaFlux::IO::FFmpegMuxContext::add_stream(), close(), codec_context, MayaFlux::Journal::FileIO, MayaFlux::IO::FFmpegMuxContext::format_context, height(), MayaFlux::Journal::IO, MayaFlux::IO::FFmpegMuxContext::is_open(), m_height, m_last_error, m_scratch_frame, m_src_pixel_fmt, m_src_src_bpp, m_stream, m_stream_index, m_width, MF_INFO, sws_context, and width().

Referenced by MayaFlux::IO::VideoFileWriter::worker_loop().

Here is the call graph for this function:

Here is the caller graph for this function: