process()

void FrameAccessProcessor::process ( const std::shared_ptr< SignalSourceContainer > &  container )

overridevirtual

Extract the current frame(s) into the container's processed_data.

Builds a Region spanning [m_current_frame .. m_current_frame + m_frames_per_batch) across the full spatial extent, delegates to get_region_data(), and copies the result into processed_data as a single interleaved DataVariant. Advances the frame cursor if auto-advance is enabled.

Parameters

container

The SignalSourceContainer to process.

Implements MayaFlux::Kakshya::DataProcessor.

Reimplemented in MayaFlux::Kakshya::FrameSeekProcessor.

Definition at line 140 of file FrameAccessProcessor.cpp.

{
    if (!m_prepared) {
        MF_RT_ERROR(Journal::Component::Kakshya, Journal::Context::ContainerProcessing,
            "FrameAccessProcessor not prepared for processing");
        return;
    }
 
    auto source_container = m_source_container_weak.lock();
    if (!source_container || source_container.get() != container.get()) {
        MF_RT_ERROR(Journal::Component::Kakshya, Journal::Context::ContainerProcessing,
            "FrameAccessProcessor: source container mismatch or expired");
        return;
    }
 
    m_is_processing = true;
    m_last_process_time = std::chrono::steady_clock::now();
 
    try {
        uint64_t frames_to_extract = std::min(m_frames_per_batch,
            m_total_frames > m_current_frame ? m_total_frames - m_current_frame : 0UL);
 
        if (frames_to_extract == 0 && m_looping_enabled && m_total_frames > 0) {
            m_current_frame = 0;
            if (!m_loop_region.start_coordinates.empty()) {
                m_current_frame = m_loop_region.start_coordinates[0];
            }
            frames_to_extract = std::min(m_frames_per_batch, m_total_frames - m_current_frame);
        }
 
        if (frames_to_extract == 0) {
            m_is_processing = false;
            return;
        }
 
        auto video_container = std::dynamic_pointer_cast<VideoStreamContainer>(source_container);
        if (!video_container) {
            MF_RT_ERROR(Journal::Component::Kakshya, Journal::Context::ContainerProcessing,
                "FrameAccessProcessor: container is not a VideoStreamContainer");
            m_is_processing = false;
            return;
        }
 
        const uint64_t byte_count = frames_to_extract * m_frame_byte_size;
 
        auto& processed_data_vector = container->get_processed_data();
        processed_data_vector.resize(1);
 
        auto* dest = std::get_if<std::vector<uint8_t>>(&processed_data_vector[0]);
        if (!dest) {
            processed_data_vector[0] = std::vector<uint8_t>();
            dest = std::get_if<std::vector<uint8_t>>(&processed_data_vector[0]);
        }
        dest->resize(byte_count);
 
        uint8_t* write_ptr = dest->data();
        bool all_ok = true;
 
        for (uint64_t i = 0; i < frames_to_extract; ++i) {
            auto pixels = video_container->get_frame_pixels(m_current_frame + i);
            if (pixels.empty()) {
                std::memset(write_ptr, 0, m_frame_byte_size);
                all_ok = false;
            } else {
                std::memcpy(write_ptr, pixels.data(), m_frame_byte_size);
            }
            write_ptr += m_frame_byte_size;
        }
 
        if (!all_ok) {
            MF_RT_ERROR(Journal::Component::Kakshya, Journal::Context::ContainerProcessing,
                "FrameAccessProcessor: one or more frames unavailable at frame {}",
                m_current_frame);
        }
 
        if (m_auto_advance) {
            if (!all_ok) {
                MF_RT_ERROR(Journal::Component::Kakshya, Journal::Context::ContainerProcessing,
                    "FrameAccessProcessor: auto-advance enabled but frame data was incomplete. Waiting for next process call without advancing frame.");
            }
            if (m_frame_rate > 0.0) {
                m_frame_accumulator += m_frame_rate / m_global_fps;
                auto frames_to_advance = static_cast<uint64_t>(m_frame_accumulator);
                if (frames_to_advance > 0) {
                    m_frame_accumulator -= static_cast<double>(frames_to_advance);
                    advance_frame(frames_to_advance);
                }
            } else {
                advance_frame(frames_to_extract);
            }
        }
 
    } catch (const std::exception& e) {
        MF_RT_ERROR(Journal::Component::Kakshya, Journal::Context::ContainerProcessing,
            "FrameAccessProcessor::process failed: {}", e.what());
    }
 
    m_is_processing = false;
}

References advance_frame(), MayaFlux::Journal::ContainerProcessing, MayaFlux::Journal::Kakshya, m_auto_advance, m_current_frame, m_frame_accumulator, m_frame_byte_size, m_frame_rate, m_frames_per_batch, m_global_fps, m_is_processing, m_last_process_time, m_loop_region, m_looping_enabled, m_prepared, m_source_container_weak, m_total_frames, MF_RT_ERROR, pixels, and MayaFlux::Kakshya::Region::start_coordinates.

Referenced by MayaFlux::Kakshya::FrameSeekProcessor::process().

Here is the call graph for this function:

Here is the caller graph for this function: