ring_buffer.cpp File Reference

#include "utils/ring_buffer.h"
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <memory>
#include <atomic>

Include dependency graph for ring_buffer.cpp:

Go to the source code of this file.

Classes
struct	ring_buffer

Functions
static int	calculate_avail_read (int start, int end, int buf_len)
static int	calculate_avail_write (int start, int end, int buf_len)
void	ring_advance_read_idx (struct ring_buffer *ring, int amount)
bool	ring_advance_write_idx (struct ring_buffer *ring, int amount)
void	ring_buffer_destroy (struct ring_buffer *ring)
void	ring_buffer_flush (struct ring_buffer *buf)
struct ring_buffer *	ring_buffer_init (int size)
int	ring_buffer_read (struct ring_buffer *ring, char *out, int max_len)
void	ring_buffer_write (struct ring_buffer *ring, const char *in, int len)
void	ring_fill (struct ring_buffer *ring, int c, int size)
int	ring_get_available_write_size (struct ring_buffer *ring)
int	ring_get_current_size (struct ring_buffer *ring)
int	ring_get_read_regions (struct ring_buffer *ring, int max_len, void **ptr1, int *size1, void **ptr2, int *size2)
int	ring_get_size (struct ring_buffer *ring)
int	ring_get_write_regions (struct ring_buffer *ring, int requested_len, void **ptr1, int *size1, void **ptr2, int *size2)

Variables
struct audio_buffer_api	ring_buffer_fns

Detailed Description

Author

Martin Pulec pulec.nosp@m.@ces.nosp@m.net.c.nosp@m.z

Martin Piatka piatk.nosp@m.a@ce.nosp@m.snet..nosp@m.cz

Definition in file ring_buffer.cpp.

Function Documentation

calculate_avail_read()

static int calculate_avail_read ( int start, int end, int buf_len )

static

Definition at line 83 of file ring_buffer.cpp.

                                                                 {
        int avail = (end - start + 2 * buf_len) % buf_len;
        if(avail == 0 && (end >= buf_len) != (start >= buf_len))
                avail += buf_len;
 
        return avail;
}

References start().

Referenced by calculate_avail_write(), ring_get_current_size(), and ring_get_read_regions().

Here is the call graph for this function:

calculate_avail_write()

static int calculate_avail_write ( int start, int end, int buf_len )

static

Definition at line 91 of file ring_buffer.cpp.

                                                                  {
        return buf_len - calculate_avail_read(start, end, buf_len); 
}

References calculate_avail_read(), and start().

Referenced by ring_advance_write_idx(), and ring_get_available_write_size().

Here is the call graph for this function:

ring_advance_read_idx()

void ring_advance_read_idx	(	struct ring_buffer *	ring,
		int	amount )

Marks memory as already read and free for writing. Use after reading using ring_get_read_regions(), or simply for discarding unwanted unread data.

Parameters

amount

amount in bytes to discard

Definition at line 127 of file ring_buffer.cpp.

                                                                 {
        // start index is modified only by this (reader) thread, so relaxed is enough
        int start = std::atomic_load_explicit(&ring->start, std::memory_order_relaxed);
 
        /* Use release order to ensure that all reads are completed (no reads
         * or writes in the current thread can be reordered after this store).
         */
        std::atomic_store_explicit(&ring->start,
                        (start + amount) % (2*ring->len), std::memory_order_release);
}

References ring_buffer::len, ring_buffer::start, and start().

Referenced by echo_cancel(), and ring_buffer_read().

Here is the call graph for this function:

ring_advance_write_idx()

bool ring_advance_write_idx	(	struct ring_buffer *	ring,
		int	amount )

Marks written memory as ready for reading. Use after writing using ring_get_write_regions().

Parameters

amount

amount in bytes to discard

Returns

true if an overflow occured

Definition at line 192 of file ring_buffer.cpp.

                                                                  {
        const int start = std::atomic_load_explicit(&ring->start, std::memory_order_acquire);
        // end index is modified only by this (writer) thread, so relaxed is enough
        const int end = std::atomic_load_explicit(&ring->end, std::memory_order_relaxed);
 
        /* Use release order to ensure that all writes to the buffer are
         * completed before advancing the end index (no reads or writes in the
         * current thread can be reordered after this store).
         */
        std::atomic_store_explicit(&ring->end,
                        (end + amount) % (2*ring->len), std::memory_order_release);
 
        return amount > calculate_avail_write(start, end, ring->len);
}

References calculate_avail_write(), ring_buffer::end, ring_buffer::len, ring_buffer::start, and start().

Referenced by audio_export_raw_ch(), echo_cancel(), echo_play(), ring_buffer_write(), and ring_fill().

Here is the call graph for this function:

ring_buffer_destroy()

void ring_buffer_destroy

(

struct ring_buffer *

ring

)

Definition at line 77 of file ring_buffer.cpp.

                                                   {
        if(ring) {
                delete ring;
        }
}

Referenced by display_bluefish444_state::~display_bluefish444_state(), audio_buffer_destroy(), audio_cap_ca_done(), audio_cap_ca_init(), audio_cap_jack_done(), audio_cap_portaudio_done(), audio_export_destroy(), cleanup_common(), display_deltacast_reconfigure_audio(), display_dvs_reconfigure_audio(), ring_buf_deleter::operator()(), and vidcap_file_common_cleanup().

ring_buffer_flush()

void ring_buffer_flush

(

struct ring_buffer *

ring

)

Flushes all data from ring buffer. Not thread safe - needs external synchronization to ensure that this is not called while the buffer is being read or written.

Definition at line 155 of file ring_buffer.cpp.

                                                 {
        /* This should only be called while the buffer is not being read or
         * written. The only way to safely flush without locking is by reading
         * all available data from the reader thread.
         */
        buf->start = 0;
        buf->end = 0;
}

References ring_buffer::end, and ring_buffer::start.

Referenced by audio_reading_thread(), flush_captured_data(), reconfigure_echo(), and reset_import().

ring_buffer_init()

struct ring_buffer * ring_buffer_init

(

int

size

)

Definition at line 66 of file ring_buffer.cpp.

                                               {
        assert(size > 0);
        auto ring = new ring_buffer();
        
        ring->data = std::make_unique<char[]>(size);
        ring->len = size;
        ring->start = 0;
        ring->end = 0;
        return ring;
}

Referenced by audio_buffer_init(), audio_cap_ca_init(), audio_cap_jack_init(), audio_cap_pipewire_init(), audio_cap_portaudio_init(), audio_cap_sdl_mixer_init(), audio_play_ca_reconfigure(), audio_play_jack_reconfigure(), audio_play_pw_reconfigure(), configure(), configure_audio(), display_deltacast_reconfigure_audio(), display_dvs_reconfigure_audio(), echo_cancellation_init(), init_audio(), set_delay_size(), and vidcap_file_init().

ring_buffer_read()

int ring_buffer_read	(	struct ring_buffer *	ring,
		char *	out,
		int	max_len )

Definition at line 138 of file ring_buffer.cpp.

                                                                        {
        void *ptr1;
        int size1;
        void *ptr2;
        int size2;
 
        int read_len = ring_get_read_regions(ring, max_len, &ptr1, &size1, &ptr2, &size2);
        
        memcpy(out, ptr1, size1);
        if(ptr2) {
                memcpy(out + size1, ptr2, size2);
        }
 
        ring_advance_read_idx(ring, read_len);
        return read_len;
}

References ring_advance_read_idx(), and ring_get_read_regions().

Referenced by audio_buffer_read(), audio_cap_ca_read(), audio_cap_jack_read(), audio_cap_pipewire_read(), audio_cap_portaudio_read(), audio_cap_sdl_mixer_read(), audio_export_thread(), display_deltacast_putf(), display_dvs_run(), echo_cancel(), filter(), get_audio(), on_process(), display_bluefish444_state::playback_loop(), sdl_audio_callback(), and vidcap_import_grab().

Here is the call graph for this function:

ring_buffer_write()

void ring_buffer_write	(	struct ring_buffer *	ring,
		const char *	in,
		int	len )

Definition at line 207 of file ring_buffer.cpp.

                                                                           {
        void *ptr1;
        int size1;
        void *ptr2;
        int size2;
        if(len == 0)
                return;
        if(!ring_get_write_regions(ring, len, &ptr1, &size1, &ptr2, &size2)){
                fprintf(stderr, "Warning: too long write request for ring buffer (%d B)!!!\n", len);
                return;
        }
 
        memcpy(ptr1, in, size1);
        if(ptr2){
                memcpy(ptr2, in + size1, size2);
        }
 
        if(ring_advance_write_idx(ring, len)) {
                fprintf(stderr, "Warning: ring buffer overflow!!!\n");
        }
}

References len, ring_advance_write_idx(), and ring_get_write_regions().

Referenced by audio_buffer_write(), audio_export_raw(), audio_play_pw_put_frame(), audio_reading_thread(), callback(), display_deltacast_put_audio_frame(), display_dvs_put_audio_frame(), display_sdl_put_audio_frame(), echo_cancel(), echo_play(), filter(), InputProc(), jack_process_callback(), on_process(), sdl_mixer_audio_callback(), and vidcap_file_write_audio().

Here is the call graph for this function:

ring_fill()

void ring_fill	(	struct ring_buffer *	ring,
		int	c,
		int	size )

Definition at line 233 of file ring_buffer.cpp.

                                                         {
        void *ptr1;
        int size1;
        void *ptr2;
        int size2;
        if(size == 0)
                return;
        if(!ring_get_write_regions(ring, size, &ptr1, &size1, &ptr2, &size2)){
                fprintf(stderr, "Warning: too long write request for ring buffer (%d B)!!!\n", size);
                return;
        }
 
        memset(ptr1, c, size1);
        if(ptr2){
                memset(ptr2, c, size2);
        }
 
        if(ring_advance_write_idx(ring, size)) {
                fprintf(stderr, "Warning: ring buffer overflow!!!\n");
        }
}

References ring_advance_write_idx(), and ring_get_write_regions().

Referenced by set_delay_size().

Here is the call graph for this function:

ring_get_available_write_size()

int ring_get_available_write_size

(

struct ring_buffer *

ring

)

Returns size available for writing

Definition at line 276 of file ring_buffer.cpp.

                                                             {
        int start = std::atomic_load_explicit(&ring->start, std::memory_order_acquire);
        int end = std::atomic_load_explicit(&ring->end, std::memory_order_acquire);
        return calculate_avail_write(start, end, ring->len);
}

References calculate_avail_write(), ring_buffer::end, ring_buffer::len, ring_buffer::start, and start().

Referenced by audio_play_pw_put_frame(), echo_cancel(), and echo_play().

Here is the call graph for this function:

ring_get_current_size()

int ring_get_current_size

(

struct ring_buffer *

ring

)

Returns actual buffer usage

Definition at line 270 of file ring_buffer.cpp.

                                                     {
        int start = std::atomic_load_explicit(&ring->start, std::memory_order_acquire);
        int end = std::atomic_load_explicit(&ring->end, std::memory_order_acquire);
        return calculate_avail_read(start, end, ring->len);
}

References calculate_avail_read(), ring_buffer::end, ring_buffer::len, ring_buffer::start, and start().

Referenced by audio_buffer_read(), audio_cap_jack_read(), audio_export_thread(), audio_reading_thread(), echo_cancel(), echo_play(), get_audio(), on_process(), vidcap_file_write_audio(), and vidcap_import_grab().

Here is the call graph for this function:

ring_get_read_regions()

int ring_get_read_regions	(	struct ring_buffer *	ring,
		int	max_len,
		void **	ptr1,
		int *	size1,
		void **	ptr2,
		int *	size2 )

Returns pointers to memory available for reading. After reading use ring_advance_read_idx() to mark the memory as free for writing.

Parameters

max_len	cap returned size to this value
ptr1	pointer to the first region
size1	size of available data in the first region
ptr2	pointer to the second region
size2	size of available data in the second region

Returns

size1 + size2

Definition at line 96 of file ring_buffer.cpp.

{
        /* end index is modified by the writer thread, use acquire order to ensure
         * that all writes by the writer thread made before the modification are
         * observable in this (reader) thread */
        int end = std::atomic_load_explicit(&ring->end, std::memory_order_acquire);
        // start index is modified only by this (reader) thread, so relaxed is enough
        int start = std::atomic_load_explicit(&ring->start, std::memory_order_relaxed);
 
        int read_len = calculate_avail_read(start, end, ring->len);
        if(read_len > max_len)
                read_len = max_len;
 
        int start_idx = start % ring->len;
        int to_end = ring->len - start_idx;
        *ptr1 = ring->data.get() + start_idx;
        if(read_len <= to_end) {
                *size1 = read_len;
                *ptr2 = nullptr;
                *size2 = 0;
        } else {
                *size1 = to_end;
                *ptr2 = ring->data.get();
                *size2 = read_len - to_end;
        }
 
        return read_len;
}

References calculate_avail_read(), ring_buffer::data, ring_buffer::end, ring_buffer::len, ring_buffer::start, and start().

Referenced by ring_buffer_read().

Here is the call graph for this function:

ring_get_size()

int ring_get_size

(

struct ring_buffer *

ring

)

Definition at line 229 of file ring_buffer.cpp.

                                             {
        return ring->len;
}

References ring_buffer::len.

Referenced by audio_reading_thread(), and display_dvs_reconfigure_audio().

ring_get_write_regions()

int ring_get_write_regions	(	struct ring_buffer *	ring,
		int	requested_len,
		void **	ptr1,
		int *	size1,
		void **	ptr2,
		int *	size2 )

Returns pointers to memory available for writing. After writing use ring_advance_write_idx() to mark the memory as available for reading.

Does not check for overflow, returns regions of requested size even if buffer is full.

If the requested_len is longer than the whole buffer, returns 0.

Parameters

requested_len	amount you want to write
ptr1	pointer to the first region
size1	size of the first region
ptr2	pointer to the second region
size2	size of the second region

Returns

size1 + size2

Definition at line 164 of file ring_buffer.cpp.

{
        *ptr1 = nullptr;
        *size1 = 0;
        *ptr2 = nullptr;
        *size2 = 0;
 
        // end index is modified only by this (writer) thread, so relaxed is enough
        int end = std::atomic_load_explicit(&ring->end, std::memory_order_relaxed);
 
        if(requested_len > ring->len) {
                return 0;
        }
 
        int end_idx = end % ring->len;
        int to_end = ring->len - end_idx;
        *ptr1 = ring->data.get() + end_idx;
        *size1 = requested_len < to_end ? requested_len : to_end;
        if(*size1 < requested_len){
                *ptr2 = ring->data.get();
                *size2 = requested_len - *size1;
        }
 
        return *size1 + *size2;
}

References ring_buffer::data, ring_buffer::end, and ring_buffer::len.

Referenced by audio_export_raw_ch(), echo_cancel(), echo_play(), ring_buffer_write(), and ring_fill().

Variable Documentation

ring_buffer_fns

struct audio_buffer_api ring_buffer_fns

Initial value:

= {
        (void (*)(void *)) ring_buffer_destroy,
        (int (*)(void *, char *, int)) ring_buffer_read,
        (void (*)(void *, const char *, int)) ring_buffer_write
}

Definition at line 282 of file ring_buffer.cpp.

                                          {
        (void (*)(void *)) ring_buffer_destroy,
        (int (*)(void *, char *, int)) ring_buffer_read,
        (void (*)(void *, const char *, int)) ring_buffer_write
};

Referenced by audio_play_ca_reconfigure(), and audio_play_jack_reconfigure().