process()

void MayaFlux::Kakshya::FrameSeekProcessor::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.

Reimplemented from MayaFlux::Kakshya::FrameAccessProcessor.

Definition at line 79 of file FrameSeekProcessor.cpp.

{
    auto source = m_source_container_weak.lock();
    auto video = std::dynamic_pointer_cast<VideoStreamContainer>(source);
 
    if (video) {
        m_total_frames = video->get_num_frames();
    }
 
    if (!m_time_map || !m_time_map->fn) {
        FrameAccessProcessor::process(container);
        return;
    }
 
    if (!m_prepared) {
        MF_RT_ERROR(Journal::Component::Kakshya, Journal::Context::ContainerProcessing,
            "FrameSeekProcessor not prepared for processing");
        return;
    }
 
    if (!video || source.get() != container.get()) {
        MF_RT_ERROR(Journal::Component::Kakshya, Journal::Context::ContainerProcessing,
            "FrameSeekProcessor: source container mismatch, expired or not a VideoStreamContainer");
        return;
    }
 
    if (m_total_frames == 0 || m_frame_byte_size == 0) {
        return;
    }
 
    m_is_processing = true;
 
    auto lo = 0.0;
    auto hi = static_cast<double>(m_total_frames);
 
    if (m_looping_enabled) {
        if (!m_loop_region.start_coordinates.empty()) {
            lo = static_cast<double>(m_loop_region.start_coordinates[0]);
        }
        if (!m_loop_region.end_coordinates.empty()) {
            hi = std::min(hi, static_cast<double>(m_loop_region.end_coordinates[0] + 1));
        }
        if (hi <= lo) {
            lo = 0.0;
            hi = static_cast<double>(m_total_frames);
        }
    }
 
    auto& processed = container->get_processed_data();
    processed.resize(1);
 
    auto* dest = std::get_if<std::vector<uint8_t>>(&processed[0]);
    if (!dest) {
        processed[0] = std::vector<uint8_t>();
        dest = std::get_if<std::vector<uint8_t>>(&processed[0]);
    }
    dest->resize(m_frames_per_batch * m_frame_byte_size);
 
    uint8_t* out = dest->data();
    uint64_t last_frame = 0;
    bool all_ok = true;
 
    for (uint64_t k = 0; k < m_frames_per_batch; ++k, out += m_frame_byte_size) {
        const double position = position_at(m_ticks + k);
        const double s = m_looping_enabled
            ? Kinesis::wrap<double>(position, lo, hi)
            : std::clamp(position, lo, hi - 1.0);
        const double whole = std::floor(s);
        const double weight = s - whole;
        const auto first = static_cast<uint64_t>(whole);
        last_frame = first;
 
        const auto a = video->get_frame_pixels(first);
        if (a.empty()) {
            std::memset(out, 0, m_frame_byte_size);
            all_ok = false;
            continue;
        }
 
        if (m_blend && weight > 0.0) {
            auto next = first + 1;
            if (static_cast<double>(next) >= hi) {
                next = m_looping_enabled ? static_cast<uint64_t>(lo) : first;
            }
 
            const auto b = video->get_frame_pixels(next);
            if (!b.empty() && blend_frames(video->get_format(), a, b, out, weight)) {
                continue;
            }
        }
 
        std::memcpy(out, a.data(), m_frame_byte_size);
    }
 
    if (!all_ok) {
        MF_RT_ERROR(Journal::Component::Kakshya, Journal::Context::ContainerProcessing,
            "FrameSeekProcessor: one or more frames unavailable near frame {}", last_frame);
    }
 
    m_ticks += m_frames_per_batch;
    m_current_frame = last_frame;
    video->update_read_position_for_channel(0, last_frame);
 
    m_is_processing = false;
}

References a, b, MayaFlux::Kakshya::blend_frames(), MayaFlux::Journal::ContainerProcessing, MayaFlux::Kakshya::Region::end_coordinates, MayaFlux::Journal::Kakshya, m_blend, MayaFlux::Kakshya::FrameAccessProcessor::m_current_frame, MayaFlux::Kakshya::FrameAccessProcessor::m_frame_byte_size, MayaFlux::Kakshya::FrameAccessProcessor::m_frames_per_batch, MayaFlux::Kakshya::FrameAccessProcessor::m_is_processing, MayaFlux::Kakshya::FrameAccessProcessor::m_loop_region, MayaFlux::Kakshya::FrameAccessProcessor::m_looping_enabled, MayaFlux::Kakshya::FrameAccessProcessor::m_prepared, MayaFlux::Kakshya::FrameAccessProcessor::m_source_container_weak, m_ticks, m_time_map, MayaFlux::Kakshya::FrameAccessProcessor::m_total_frames, MF_RT_ERROR, out, position, position_at(), MayaFlux::Kakshya::FrameAccessProcessor::process(), MayaFlux::Kakshya::Region::start_coordinates, and weight.

Here is the call graph for this function: