shared_ring.h

Go to the documentation of this file.

#ifndef MF_SHARED_RING_H_
#define MF_SHARED_RING_H_

#include "timed_ring.h"
#include "../os/event.h"
#include <mutex>
#include <condition_variable>
#include <stdexcept>
#include <atomic>
#include <ostream>

namespace mf {


class shared_ring {
public:
    using section_view_type = timed_ring::section_view_type;

private:

    using thread_state = time_unit;
    enum : thread_state { idle = 0, accessing = -1 };

    timed_ring ring_; 

    const bool seekable_;

    std::atomic<time_unit> end_time_{-1};
    // TODO make non-atomic? verify

    mutable std::mutex mutex_; 
    event reader_idle_event_; 
    event reader_seek_event_; 
    event writer_idle_event_; 

    std::atomic<thread_state> reader_state_{idle}; 
    std::atomic<thread_state> writer_state_{idle}; 
    
    std::atomic<time_unit> read_start_time_{0}; 
        
    void skip_available_(time_unit duration);
    void read_and_discard_(time_unit duration);
    
public:
    shared_ring(const frame_array_properties&, bool seekable, time_unit end_time = -1);
        
    void initialize();
    
    const frame_format& format() const noexcept { return ring_.format(); }


    time_unit capacity() const { return ring_.shape().front(); }


    section_view_type begin_write(time_unit write_duration);


    section_view_type try_begin_write(time_unit write_duration);


    bool wait_writable(event& break_event);
    

    void end_write(time_unit written_duration, bool mark_end = false);


    section_view_type begin_read_span(time_span);
    

    section_view_type begin_read(time_unit read_duration);


    section_view_type try_begin_read(time_unit read_duration);


    bool wait_readable(event& break_event);

    

    void end_read(time_unit read_duration); 
    

    void skip(time_unit skip_duration);
    

    bool is_seekable() const { return seekable_; }
    

    void seek(time_unit target_time);
    
    

    bool can_seek(time_unit target_time) const;
    

    time_unit current_time() const;
    

    time_unit write_start_time() const;
    

    time_unit read_start_time() const;
        

    time_span writable_time_span() const;
    

    time_span readable_time_span() const;
    

    time_unit writable_duration() const { return writable_time_span().duration(); }


    time_unit readable_duration() const { return readable_time_span().duration(); }


    time_unit end_time() const { return end_time_; }
    
    bool end_time_is_defined() const { return (end_time_ != -1); }
    

    bool writer_reached_end() const;


    bool reader_reached_end() const;
};


}

#endif