audio_buffer.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	audio_buffer_api

Typedefs
typedef struct audio_buffer	audio_buffer_t

Functions
void	audio_buffer_destroy (struct audio_buffer *buf)
struct audio_buffer *	audio_buffer_init (int sample_rate, int bps, int ch_count, int suggested_latency_ms)
int	audio_buffer_read (struct audio_buffer *buf, char *out, int max_len)
void	audio_buffer_write (struct audio_buffer *buf, const char *in, int len)

Variables
struct audio_buffer_api	audio_buffer_fns

Detailed Description

Author

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

Definition in file audio_buffer.h.

Typedef Documentation

audio_buffer_t

typedef struct audio_buffer audio_buffer_t

Definition at line 46 of file audio_buffer.h.

Function Documentation

audio_buffer_destroy()

void audio_buffer_destroy

(

struct audio_buffer *

buf

)

Definition at line 99 of file audio_buffer.c.

{
        if (!buf) {
                return;
        }
        ring_buffer_destroy(buf->ring);
        free(buf);
}

References audio_buffer::ring, and ring_buffer_destroy().

Referenced by am_participant::~am_participant(), audio_play_alsa_done(), audio_play_alsa_reconfigure(), and cleanup().

Here is the call graph for this function:

audio_buffer_init()

struct audio_buffer * audio_buffer_init	(	int	sample_rate,
		int	bps,
		int	ch_count,
		int	suggested_latency_ms )

Definition at line 80 of file audio_buffer.c.

{
        struct audio_buffer *buf = calloc(1, sizeof(struct audio_buffer));
        buf->desc.sample_rate = sample_rate;
        buf->desc.bps = bps;
        buf->desc.ch_count = ch_count;
 
        buf->last_underrun = BUF_LAST_UNDERRUN_MAX;
 
        buf->ring = ring_buffer_init(sample_rate * bps * ch_count);
 
        buf->suggested_latency_ms = suggested_latency_ms;
 
        buf->aggressivity = 1;
        buf->last_aggressivity_change = AGGRESSIVITY_STEP;
 
        return buf;
}

References audio_buffer::aggressivity, AGGRESSIVITY_STEP, audio_desc::bps, BUF_LAST_UNDERRUN_MAX, audio_desc::ch_count, audio_buffer::desc, audio_buffer::last_aggressivity_change, audio_buffer::last_underrun, audio_buffer::ring, ring_buffer_init(), audio_desc::sample_rate, sample_rate, and audio_buffer::suggested_latency_ms.

Referenced by am_participant::am_participant(), audio_play_alsa_reconfigure(), audio_play_ca_reconfigure(), audio_play_jack_reconfigure(), and audio_play_portaudio_reconfigure().

Here is the call graph for this function:

audio_buffer_read()

int audio_buffer_read	(	struct audio_buffer *	buf,
		char *	out,
		int	max_len )

Definition at line 108 of file audio_buffer.c.

{
        if (buf->out_pkt_size > 0) {
                buf->out_pkt_size = (max_len + (buf->out_pkt_size * (WINDOW-1))) / WINDOW;
        } else {
                buf->out_pkt_size = max_len;
        }
 
        int ring_size = ring_get_current_size(buf->ring);
 
        for (unsigned int i = 0; i < sizeof buf->avg_occupancy / sizeof buf->avg_occupancy[0]; ++i) {
                if (buf->avg_occupancy[i] > 0) {
                        buf->avg_occupancy[i] = (ring_size + (buf->avg_occupancy[i] * (occupacy_windows[i] -1))) / occupacy_windows[i];
                } else {
                        buf->avg_occupancy[i] = ring_size;
                }
        }
 
        // handle underruns
        if (ring_size < max_len) {
                buf->last_underrun = 0;
        } else {
                if (buf->last_underrun < BUF_LAST_UNDERRUN_MAX) {
                        buf->last_underrun += 1;
                }
        }
 
        int suggested_latency_bytes = buf->suggested_latency_ms * buf->desc.bps * buf->desc.ch_count * buf->desc.sample_rate / 1000;
        int requested_latency_bytes = max(suggested_latency_bytes, 2*max(buf->in_pkt_size, buf->out_pkt_size));
 
        int ret = ring_buffer_read(buf->ring, out, max_len);
 
        // fiddle aggressivity
        if (buf->last_aggressivity_change >= AGGRESSIVITY_STEP) {
                buf->last_aggressivity_change = 0;
                if ((buf->avg_occupancy[0] > buf->avg_occupancy[1] && buf->last_underrun > BUF_LAST_UNDERRUN_THRESHOLD / 10) && buf->last_overrun <= BUF_LAST_OVERRUN_THRESHOLD) {
                        buf->aggressivity = min(buf->aggressivity + 1, AGGRESSIVITY_MAX);
                } else if (buf->avg_occupancy[0] < buf->avg_occupancy[1] || buf->last_underrun < BUF_LAST_UNDERRUN_THRESHOLD / 100 || buf->last_overrun > BUF_LAST_OVERRUN_THRESHOLD) {
                        buf->aggressivity = max(buf->aggressivity - 1, 1);
                }
        } else {
                buf->last_aggressivity_change += 1;
        }
 
        // handle overruns
        int remaining_bytes = ring_size - ret;
        if (requested_latency_bytes < remaining_bytes) {
                int len_drop = (1<<buf->aggressivity) * buf->desc.bps * buf->desc.ch_count * 128;
                len_drop = min(len_drop, remaining_bytes / 2);
 
                char *tmp = alloca(len_drop);
                ring_buffer_read(buf->ring, tmp, len_drop);
                buf->last_overrun = 0;
                log_msg(LOG_LEVEL_VERBOSE, "Dropped audio samples: req latency %d remaining %d dropped %d!\n", requested_latency_bytes, remaining_bytes, len_drop);
        } else {
                buf->last_overrun += 1;
        }
 
        log_msg(LOG_LEVEL_DEBUG, "buf - in a. %d, out a. %d, occ. a. [%d,%d] last under/overrun %d, %d aggressivity %d\n", buf->in_pkt_size, buf->out_pkt_size, buf->avg_occupancy[0],buf->avg_occupancy[1], buf->last_underrun, buf->last_overrun, buf->aggressivity);
 
        return ret;
}

References audio_buffer::aggressivity, AGGRESSIVITY_MAX, AGGRESSIVITY_STEP, audio_buffer::avg_occupancy, audio_desc::bps, BUF_LAST_OVERRUN_THRESHOLD, BUF_LAST_UNDERRUN_MAX, BUF_LAST_UNDERRUN_THRESHOLD, audio_desc::ch_count, audio_buffer::desc, audio_buffer::in_pkt_size, audio_buffer::last_aggressivity_change, audio_buffer::last_overrun, audio_buffer::last_underrun, LOG_LEVEL_DEBUG, LOG_LEVEL_VERBOSE, log_msg(), max, min, occupacy_windows, audio_buffer::out_pkt_size, audio_buffer::ring, ring_buffer_read(), ring_get_current_size(), audio_desc::sample_rate, audio_buffer::suggested_latency_ms, and WINDOW.

Referenced by alsa_play_async_callback(), callback(), state_audio_mixer::worker(), and worker().

Here is the call graph for this function:

audio_buffer_write()

void audio_buffer_write	(	struct audio_buffer *	buf,
		const char *	in,
		int	len )

Definition at line 171 of file audio_buffer.c.

{
        if (buf->in_pkt_size > 0) {
                buf->in_pkt_size = (len + (buf->in_pkt_size * (WINDOW-1))) / WINDOW;
        } else {
                buf->in_pkt_size = len;
        }
        ring_buffer_write(buf->ring, in, len);
}

References audio_buffer::in_pkt_size, len, audio_buffer::ring, ring_buffer_write(), and WINDOW.

Referenced by audio_play_alsa_put_frame(), audio_play_mixer_put_frame(), and audio_play_portaudio_put_frame().

Here is the call graph for this function:

Variable Documentation

audio_buffer_fns

struct audio_buffer_api audio_buffer_fns

extern

Definition at line 181 of file audio_buffer.c.

                                           {
        (void (*)(void *)) audio_buffer_destroy,
        (int (*)(void *, char *, int)) audio_buffer_read,
        (void (*)(void *, const char *, int)) audio_buffer_write,
};

Referenced by audio_play_ca_reconfigure(), and audio_play_jack_reconfigure().