setup_ring()

void MayaFlux::Kakshya::VideoStreamContainer::setup_ring	(	uint64_t	total_frames,
		uint32_t	ring_capacity,
		uint32_t	width,
		uint32_t	height,
		Portal::Graphics::ImageFormat	format,
		double	frame_rate,
		uint32_t	refill_threshold,
		uint64_t	reader_id = 0
	)

Allocate m_data[0] as a ring of ring_capacity frames.

Switches the container from flat mode to ring mode. m_data[0] is resized to ring_capacity x frame_byte_size. m_num_frames is set to total_frames so processors see the full temporal extent. Pixel data is indexed by frame_index % ring_capacity.

Parameters

total_frames	Total frames in the source (file, stream, etc).
ring_capacity	Number of frame slots (must be power of 2).
width	Frame width in pixels.
height	Frame height in pixels.
format	Pixel format for the ring's frames.
frame_rate	Frame rate in fps.
refill_threshold	Frames of look-ahead below which refill callback fires.
reader_id	The current class ID registered at the stream/file-read source

Definition at line 118 of file VideoStreamContainer.cpp.

{
    {
        Memory::SeqlockWriteGuard g(m_data_lock);
 
        m_width = width;
        m_height = height;
        m_format = format;
        m_channels = Portal::Graphics::TextureLoom::get_channel_count(format);
        m_bpp = Portal::Graphics::TextureLoom::get_bytes_per_pixel(format);
        m_structure.modality = is_depth_format(format)
            ? DataModality::VIDEO_DEPTH
            : DataModality::VIDEO_COLOR;
 
        m_frame_rate = frame_rate;
        m_total_source_frames = total_frames;
        m_ring_capacity = ring_capacity;
        m_num_frames = total_frames;
        m_cache_head.store(0, std::memory_order_relaxed);
        m_refill_threshold = refill_threshold;
        m_io_reader_id = reader_id;
 
        m_io_service = Registry::BackendRegistry::instance()
                           .get_service<Registry::Service::IOService>();
 
        const size_t frame_bytes = get_frame_byte_size();
 
        m_data.resize(1);
        auto& pixels = m_data[0].emplace<std::vector<uint8_t>>();
        pixels.resize(frame_bytes * ring_capacity, 0);
 
        m_slot_frame = std::vector<std::atomic<uint64_t>>(ring_capacity);
        for (auto& sf : m_slot_frame)
            sf.store(UINT64_MAX, std::memory_order_relaxed);
 
        m_ready_queue.reset();
        setup_dimensions();
    }
 
    if (m_float_frame_cache.size() != ring_capacity) {
        m_float_frame_cache.resize(ring_capacity);
        m_float_frame_dirty = std::vector<std::atomic<bool>>(ring_capacity);
 
        for (auto& flag : m_float_frame_dirty)
            flag.store(true, std::memory_order_relaxed);
    }
 
    update_processing_state(ProcessingState::IDLE);
}

References MayaFlux::Portal::Graphics::TextureLoom::get_bytes_per_pixel(), MayaFlux::Portal::Graphics::TextureLoom::get_channel_count(), get_frame_byte_size(), MayaFlux::Registry::BackendRegistry::get_service(), height, MayaFlux::Kakshya::IDLE, MayaFlux::Registry::BackendRegistry::instance(), MayaFlux::Kakshya::is_depth_format(), m_bpp, m_cache_head, m_channels, m_data, m_data_lock, m_float_frame_cache, m_float_frame_dirty, m_format, m_frame_rate, m_height, m_io_reader_id, m_io_service, m_num_frames, m_ready_queue, m_refill_threshold, m_ring_capacity, m_slot_frame, m_structure, m_total_source_frames, m_width, MayaFlux::Kakshya::ContainerDataStructure::modality, pixels, setup_dimensions(), update_processing_state(), MayaFlux::Kakshya::VIDEO_COLOR, MayaFlux::Kakshya::VIDEO_DEPTH, and width.

Here is the call graph for this function: