processed_frame_as_float()

std::span< const float > MayaFlux::Kakshya::VideoStreamContainer::processed_frame_as_float

(

uint64_t

frame_index = 0

)

const

Processed frame at frame_index as a normalised float span.

Valid after FrameAccessProcessor has written processed_data. uint8_t source values are divided by 255.0f. float source is zero-copy. Returns empty span if frame_index is out of range or the variant holds a non-pixel type.

The cache covers the last requested frame_index only. A call with a different index invalidates and recomputes.

Parameters

frame_index

Zero-based index into processed_data. Defaults to 0.

Returns

Normalised float span, w * h * channels elements.

Definition at line 844 of file VideoStreamContainer.cpp.

{
    if (frame_index >= m_processed_data.size())
        return {};
 
    if (frame_index >= m_float_frame_dirty.size()) {
        const size_t old_size = m_float_frame_dirty.size();
        const size_t new_size = frame_index + 1;
        auto new_dirty = std::vector<std::atomic<bool>>(new_size);
 
        for (size_t i = 0; i < old_size; ++i) {
            new_dirty[i].store(m_float_frame_dirty[i].load(std::memory_order_relaxed),
                std::memory_order_relaxed);
        }
 
        for (size_t i = old_size; i < new_size; ++i)
            new_dirty[i].store(true, std::memory_order_relaxed);
        m_float_frame_dirty = std::move(new_dirty);
        m_float_frame_cache.resize(new_size);
    }
 
    if (!m_float_frame_dirty[frame_index].load(std::memory_order_acquire))
        return { m_float_frame_cache[frame_index] };
 
    auto result = as_normalised_float(m_processed_data[frame_index], m_float_frame_cache[frame_index]);
    if (!result.empty())
        m_float_frame_dirty[frame_index].store(false, std::memory_order_release);
 
    return result;
}

References MayaFlux::Kakshya::as_normalised_float(), m_float_frame_cache, m_float_frame_dirty, m_processed_data, and MayaFlux::store().

Here is the call graph for this function: