open()

bool MayaFlux::IO::VideoStreamContext::open	(	const FFmpegDemuxContext &	demux,
		uint32_t	target_width = 0,
		uint32_t	target_height = 0,
		int	target_format = -1
	)

Open the video stream from an already-probed demux context.

Finds the best video stream, allocates and opens the codec context, caches video parameters, and initialises the SwsContext for conversion to the target pixel format (default AV_PIX_FMT_RGBA).

Parameters

demux	Open demux context (must outlive this object).
target_width	Output width in pixels; 0 = keep source width.
target_height	Output height in pixels; 0 = keep source height.
target_format	Target AVPixelFormat; negative = AV_PIX_FMT_RGBA.

Returns

True on success.

Definition at line 52 of file VideoStreamContext.cpp.

{
    close();
    FFmpegDemuxContext::init_ffmpeg();
 
    if (!demux.is_open()) {
        m_last_error = "Demux context is not open";
        return false;
    }
 
    const AVCodec* codec = nullptr;
    stream_index = demux.find_best_stream(AVMEDIA_TYPE_VIDEO,
        reinterpret_cast<const void**>(&codec));
    if (stream_index < 0 || !codec) {
        m_last_error = "No video stream found";
        return false;
    }
 
    codec_context = avcodec_alloc_context3(codec);
    if (!codec_context) {
        m_last_error = "avcodec_alloc_context3 failed";
        return false;
    }
 
    AVStream* stream = demux.get_stream(stream_index);
    if (avcodec_parameters_to_context(codec_context, stream->codecpar) < 0) {
        m_last_error = "avcodec_parameters_to_context failed";
        close();
        return false;
    }
 
    if (avcodec_open2(codec_context, codec, nullptr) < 0) {
        m_last_error = "avcodec_open2 failed";
        close();
        return false;
    }
 
#ifdef MAYAFLUX_PLATFORM_WINDOWS
    uint32_t probed_width = 0;
    uint32_t probed_height = 0;
 
    if (codec_context->pix_fmt == AV_PIX_FMT_NONE) {
        AVPacket* probe_pkt = av_packet_alloc();
        AVFrame* probe_frm = av_frame_alloc();
 
        if (probe_pkt && probe_frm) {
            AVFormatContext* fmt = demux.format_context;
            bool probed = false;
 
            while (!probed && av_read_frame(fmt, probe_pkt) >= 0) {
                if (probe_pkt->stream_index != stream_index) {
                    av_packet_unref(probe_pkt);
                    continue;
                }
                if (avcodec_send_packet(codec_context, probe_pkt) >= 0) {
                    if (avcodec_receive_frame(codec_context, probe_frm) >= 0) {
                        if (codec_context->pix_fmt == AV_PIX_FMT_NONE
                            && probe_frm->format != AV_PIX_FMT_NONE) {
                            codec_context->pix_fmt = static_cast<AVPixelFormat>(probe_frm->format);
                        }
                        probed_width = static_cast<uint32_t>(probe_frm->width);
                        probed_height = static_cast<uint32_t>(probe_frm->height);
                        probed = true;
                        av_frame_unref(probe_frm);
                    }
                }
                av_packet_unref(probe_pkt);
            }
        }
 
        av_packet_free(&probe_pkt);
        av_frame_free(&probe_frm);
        avcodec_flush_buffers(codec_context);
    }
 
    width = static_cast<uint32_t>(codec_context->width);
    height = static_cast<uint32_t>(codec_context->height);
 
    if (probed_width > 0 && probed_height > 0) {
        width = probed_width;
        height = probed_height;
        codec_context->width = static_cast<int>(width);
        codec_context->height = static_cast<int>(height);
    }
#else
    width = static_cast<uint32_t>(codec_context->width);
    height = static_cast<uint32_t>(codec_context->height);
#endif
 
    if (codec_context->codec_id == AV_CODEC_ID_HEVC
        && stream->r_frame_rate.den > 0
        && stream->r_frame_rate.num > 0) {
        frame_rate = av_q2d(stream->r_frame_rate);
    } else if (stream->avg_frame_rate.den > 0 && stream->avg_frame_rate.num > 0) {
        frame_rate = av_q2d(stream->avg_frame_rate);
    } else if (stream->r_frame_rate.den > 0 && stream->r_frame_rate.num > 0) {
        frame_rate = av_q2d(stream->r_frame_rate);
    }
 
    src_pixel_format = codec_context->pix_fmt;
 
    if (stream->nb_frames > 0) {
        total_frames = static_cast<uint64_t>(stream->nb_frames);
    } else if (stream->duration != AV_NOPTS_VALUE
        && stream->time_base.num > 0 && stream->time_base.den > 0
        && frame_rate > 0.0) {
        double dur = static_cast<double>(stream->duration) * av_q2d(stream->time_base);
        total_frames = static_cast<uint64_t>(dur * frame_rate);
    } else if (demux.format_context->duration != AV_NOPTS_VALUE && frame_rate > 0.0) {
        double dur = static_cast<double>(demux.format_context->duration)
            / static_cast<double>(AV_TIME_BASE);
        total_frames = static_cast<uint64_t>(dur * frame_rate);
    }
 
    MF_INFO(Journal::Component::IO, Journal::Context::FileIO,
        "[VideoStreamContext] stream #{} | "
        "avg_frame_rate={}/{} ({:.6f} fps) | "
        "r_frame_rate={}/{} ({:.6f} fps) | "
        "chosen frame_rate={:.6f} fps | "
        "nb_frames={} | "
        "stream duration={} (tb={}/{}, => {:.4f}s) | "
        "format duration={} (=> {:.4f}s) | "
        "total_frames={} | "
        "source={}",
        stream_index,
        stream->avg_frame_rate.num, stream->avg_frame_rate.den,
        (stream->avg_frame_rate.den > 0 ? av_q2d(stream->avg_frame_rate) : 0.0),
        stream->r_frame_rate.num, stream->r_frame_rate.den,
        (stream->r_frame_rate.den > 0 ? av_q2d(stream->r_frame_rate) : 0.0),
        frame_rate,
        static_cast<int64_t>(stream->nb_frames),
        stream->duration,
        stream->time_base.num, stream->time_base.den,
        (stream->duration != AV_NOPTS_VALUE && stream->time_base.den > 0
                ? static_cast<double>(stream->duration) * av_q2d(stream->time_base)
                : -1.0),
        demux.format_context->duration,
        (demux.format_context->duration != AV_NOPTS_VALUE
                ? static_cast<double>(demux.format_context->duration) / AV_TIME_BASE
                : -1.0),
        total_frames,
        (stream->nb_frames > 0 ? "nb_frames"
                               : (stream->duration != AV_NOPTS_VALUE ? "stream_duration*fps"
                                                                     : "format_duration*fps")));
 
    if (!setup_scaler(target_width, target_height, target_format)) {
        close();
        return false;
    }
 
    return true;
}

References close(), codec_context, MayaFlux::Journal::FileIO, MayaFlux::IO::FFmpegDemuxContext::find_best_stream(), MayaFlux::IO::FFmpegDemuxContext::format_context, frame_rate, MayaFlux::IO::FFmpegDemuxContext::get_stream(), height, MayaFlux::IO::FFmpegDemuxContext::init_ffmpeg(), MayaFlux::Journal::IO, MayaFlux::IO::FFmpegDemuxContext::is_open(), m_last_error, MF_INFO, setup_scaler(), src_pixel_format, stream_index, target_format, target_height, target_width, total_frames, and width.

Here is the call graph for this function: