load_into_container()

bool MayaFlux::IO::VideoFileReader::load_into_container ( std::shared_ptr< Kakshya::SignalSourceContainer >  container )

overridevirtual

Load file data into an existing container.

Parameters

container

Target container (must be compatible type).

Returns

true if successful.

Implements MayaFlux::IO::FileReader.

Definition at line 253 of file VideoFileReader.cpp.

{
    if (!container) {
        set_error("Invalid container");
        return false;
    }
 
    auto vc = std::dynamic_pointer_cast<Kakshya::VideoFileContainer>(container);
    if (!vc) {
        set_error("Container is not a VideoFileContainer");
        return false;
    }
 
    std::shared_ptr<VideoStreamContext> video;
    std::shared_ptr<AudioStreamContext> audio;
    std::shared_ptr<FFmpegDemuxContext> demux;
    {
        std::shared_lock lock(m_context_mutex);
        if (!m_demux || !m_video) {
            set_error("File not open");
            return false;
        }
        video = m_video;
        audio = m_audio;
        demux = m_demux;
    }
 
    vc->set_source_path(m_filepath);
    if (m_demux && m_demux->format_context)
        vc->set_source_format(m_demux->format_context->iformat->name);
 
    const uint64_t total = video->total_frames;
    if (total == 0) {
        set_error("Video stream reports 0 frames");
        return false;
    }
 
    const uint32_t ring_cap = std::min(
        m_ring_capacity,
        static_cast<uint32_t>(total));
 
    const uint32_t threshold = (m_refill_threshold > 0)
        ? m_refill_threshold
        : ring_cap / 4;
 
    const auto fmt = to_image_format(video->out_pixel_format);
    if (!fmt) {
        set_error("Video output pixel format has no ImageFormat equivalent");
        return false;
    }
 
    vc->setup_ring(total, ring_cap,
        video->out_width, video->out_height,
        *fmt, video->frame_rate,
        threshold, m_reader_id);
 
    m_sws_buf.resize(
        static_cast<size_t>(video->out_linesize) * video->out_height);
 
    bool want_audio = (m_video_options & VideoReadOptions::EXTRACT_AUDIO)
            != VideoReadOptions::NONE
        && demux->find_best_stream(AVMEDIA_TYPE_AUDIO) >= 0;
 
    if (want_audio && audio && audio->is_valid()) {
        {
            std::unique_lock lock(m_context_mutex);
            demux->seek(audio->stream_index, 0);
            audio->flush_codec();
            audio->drain_resampler_init();
        }
 
        SoundFileReader audio_reader;
        audio_reader.set_audio_options(m_audio_options);
        audio_reader.set_target_sample_rate(m_target_sample_rate);
 
        if (audio_reader.open_from_demux(demux, audio, m_filepath, m_options)) {
            auto sc = audio_reader.create_container();
            if (audio_reader.load_into_container(sc)) {
                m_audio_container = std::dynamic_pointer_cast<Kakshya::SoundFileContainer>(sc);
            } else {
                MF_WARN(Journal::Component::IO, Journal::Context::FileIO,
                    "VideoFileReader: audio load failed: {}",
                    audio_reader.get_last_error());
            }
        } else {
            MF_WARN(Journal::Component::IO, Journal::Context::FileIO,
                "VideoFileReader: open_from_demux failed: {}",
                audio_reader.get_last_error());
        }
 
        {
            std::unique_lock lock(m_context_mutex);
            demux->seek(video->stream_index, 0);
            video->flush_codec();
        }
    }
 
    m_decode_head.store(0);
    m_container_ref = vc;
 
    const uint64_t preload = std::min(
        static_cast<uint64_t>(ring_cap),
        total);
 
    uint64_t decoded = decode_batch(*vc, preload);
 
    if (decoded == 0) {
        set_error("Failed to decode any frames during preload");
        return false;
    }
 
    MF_INFO(Journal::Component::IO, Journal::Context::FileIO,
        "VideoFileReader: preloaded {}/{} frames ({}x{}, {:.1f} fps, ring={})",
        decoded, total,
        video->out_width, video->out_height,
        video->frame_rate, ring_cap);
 
    auto regions = get_regions();
    auto region_groups = regions_to_groups(regions);
    for (const auto& [name, group] : region_groups)
        vc->add_region_group(group);
 
    vc->create_default_processor();
    vc->mark_ready_for_processing(true);
 
    if (decoded < total)
        start_decode_thread();
 
    return true;
}

References MayaFlux::IO::SoundFileReader::create_container(), decode_batch(), MayaFlux::IO::EXTRACT_AUDIO, MayaFlux::Journal::FileIO, MayaFlux::IO::SoundFileReader::get_last_error(), get_regions(), MayaFlux::Journal::IO, MayaFlux::IO::SoundFileReader::load_into_container(), m_audio, m_audio_container, m_audio_options, m_container_ref, m_context_mutex, m_decode_head, m_demux, m_filepath, m_options, m_reader_id, m_refill_threshold, m_ring_capacity, m_sws_buf, m_target_sample_rate, m_video, m_video_options, MF_INFO, MF_WARN, name, MayaFlux::IO::NONE, MayaFlux::IO::SoundFileReader::open_from_demux(), MayaFlux::IO::FileReader::regions_to_groups(), MayaFlux::IO::SoundFileReader::set_audio_options(), set_error(), MayaFlux::IO::SoundFileReader::set_target_sample_rate(), start_decode_thread(), threshold, and MayaFlux::IO::to_image_format().

Here is the call graph for this function: