load_video() [2/2]

VideoLoadResult MayaFlux::IO::IOManager::load_video	(	const std::string &	filepath,
		VideoLoadConfig	config
	)

Load a video file into a VideoFileContainer.

Performs can_read check, opens with metadata and region extraction, registers the reader (assigning a globally unique reader_id), calls setup_io_service(), loads into container, and configures the default FrameAccessProcessor with auto_advance enabled.

Passing VideoReadOptions::EXTRACT_AUDIO also extracts the embedded SoundFileContainer, configures its ContiguousAccessProcessor identically to load_audio_file() in Depot, and fills the audio half of the result.

Parameters

filepath	Path to the video file.
config	VideoLoadConfig containing options and target dimensions.

Returns

The video container and, if requested and present, its audio container.

Definition at line 251 of file IOManager.cpp.

{
    auto reader = std::make_shared<IO::VideoFileReader>();
 
    if (!reader->can_read(filepath)) {
        MF_ERROR(Journal::Component::API, Journal::Context::FileIO,
            "Cannot read video file: {}", filepath);
        return {};
    }
 
    reader->set_video_options(config.video_options);
    reader->set_audio_options(config.audio_options);
    reader->set_target_dimensions(config.target_width, config.target_height);
 
    if ((config.video_options & VideoReadOptions::EXTRACT_AUDIO) == VideoReadOptions::EXTRACT_AUDIO) {
        reader->set_target_sample_rate(m_stream_info.sample_rate);
    }
 
    if (!reader->open(filepath, config.file_options)) {
        MF_ERROR(Journal::Component::API, Journal::Context::FileIO,
            "Failed to open video file: {}", reader->get_last_error());
        return {};
    }
 
    const uint64_t reader_id = register_video_reader(reader);
    reader->setup_io_service(reader_id);
 
    auto video_container = std::dynamic_pointer_cast<Kakshya::VideoFileContainer>(reader->create_container());
 
    if (!video_container) {
        MF_ERROR(Journal::Component::API, Journal::Context::Runtime,
            "Failed to create video container from: {}", filepath);
        release_video_reader(reader_id);
        return {};
    }
 
    if (!reader->load_into_container(video_container)) {
        MF_ERROR(Journal::Component::API, Journal::Context::FileIO,
            "Failed to load video data: {}", reader->get_last_error());
        release_video_reader(reader_id);
        return {};
    }
 
    configure_frame_processor(video_container);
 
    std::shared_ptr<Kakshya::SoundFileContainer> audio_container;
 
    if ((config.video_options & IO::VideoReadOptions::EXTRACT_AUDIO) == IO::VideoReadOptions::EXTRACT_AUDIO) {
        audio_container = reader->get_audio_container();
        if (audio_container) {
            configure_audio_processor(audio_container);
            m_extracted_audio[video_container] = audio_container;
        } else {
            MF_WARN(Journal::Component::API, Journal::Context::FileIO,
                "No audio track found in: {}", filepath);
        }
    }
 
    MF_INFO(Journal::Component::API, Journal::Context::FileIO,
        "Loaded video: {}", filepath);
 
    return { std::move(video_container), std::move(audio_container) };
}

References MayaFlux::Journal::API, MayaFlux::IO::VideoLoadConfig::audio_options, configure_audio_processor(), configure_frame_processor(), MayaFlux::IO::EXTRACT_AUDIO, MayaFlux::IO::VideoLoadConfig::file_options, MayaFlux::Journal::FileIO, m_extracted_audio, m_stream_info, MF_ERROR, MF_INFO, MF_WARN, register_video_reader(), release_video_reader(), MayaFlux::Journal::Runtime, MayaFlux::Core::GlobalStreamInfo::sample_rate, MayaFlux::IO::VideoLoadConfig::target_height, MayaFlux::IO::VideoLoadConfig::target_width, and MayaFlux::IO::VideoLoadConfig::video_options.

Here is the call graph for this function: