export.c File Reference

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "audio/audio.h"
#include "audio/utils.h"
#include "audio/wav_writer.h"
#include "debug.h"
#include "export.h"
#include "utils/misc.h"
#include "utils/ring_buffer.h"

Include dependency graph for export.c:

Go to the source code of this file.

Classes
struct	audio_export

Macros
#define	CACHE_SECONDS   10

Functions
void	audio_export (struct audio_export *s, const struct audio_frame *frame)
bool	audio_export_configure_raw (struct audio_export *s, int bps, int sample_rate, int ch_count)
void	audio_export_destroy (struct audio_export *s)
struct audio_export *	audio_export_init (const char *filename)
void	audio_export_raw (struct audio_export *s, void *data, unsigned len)
void	audio_export_raw_ch (struct audio_export *s, const void **channels_data, unsigned sample_count)
static void *	audio_export_thread (void *arg)
static bool	configure (struct audio_export *s, struct audio_desc fmt)
static int	write_samples (char *out, const void **channels_data, int bps, int ch_count, int size, int start_sample)

Detailed Description

Author

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

Definition in file export.c.

Macro Definition Documentation

CACHE_SECONDS

#define CACHE_SECONDS   10

Definition at line 57 of file export.c.

Referenced by configure().

Function Documentation

audio_export()

void audio_export	(	struct audio_export *	s,
		const struct audio_frame *	frame )

Definition at line 221 of file export.c.

{
        if(!s) {
                return;
        }
 
        if(s->saved_format.ch_count == 0) {
                bool res;
                res = configure(s, audio_desc_from_frame(frame));
                if(!res) {
                        fprintf(stderr, "[Audio export] Configuration failed.\n");
                        return;
                }
                pthread_create(&s->thread_id, NULL, audio_export_thread, s);
        } else {
                if(!audio_desc_eq(s->saved_format,
                                        audio_desc_from_frame(frame))) {
                        return;
                }
        }
 
        audio_export_raw(s, frame->data, frame->data_len);
}

References audio_desc_eq(), audio_desc_from_frame(), audio_export_raw(), audio_export_thread(), audio_desc::ch_count, configure(), frame, audio_export::saved_format, and audio_export::thread_id.

Referenced by audio_play_dump_put_frame(), and export_audio().

Here is the call graph for this function:

audio_export_configure_raw()

bool audio_export_configure_raw	(	struct audio_export *	s,
		int	bps,
		int	sample_rate,
		int	ch_count )

Configure audio export for exporting samples directly from a sample buffer. Cannot be called when export is already configured by a previous call to this function, or by audio_export().

Definition at line 136 of file export.c.

{
 
        assert(s->saved_format.ch_count == 0 && "Audio export already configured");
        struct audio_desc fmt;
 
        fmt.codec = AC_PCM;
        fmt.bps = bps;
        fmt.sample_rate = sample_rate;
        fmt.ch_count = ch_count;
 
        bool res = configure(s, fmt);
 
        if(!res) {
                fprintf(stderr, "[Audio export] Configuration failed.\n");
                return false;
        }
        pthread_create(&s->thread_id, NULL, audio_export_thread, s);
 
        return true;
}

References AC_PCM, audio_export_thread(), audio_desc::bps, audio_desc::ch_count, audio_desc::codec, configure(), fmt, sample_rate, audio_export::saved_format, and audio_export::thread_id.

Referenced by reconfigure_echo().

Here is the call graph for this function:

audio_export_destroy()

void audio_export_destroy

(

struct audio_export *

s

)

Definition at line 182 of file export.c.

{
        if(s) {
                if(s->thread_id) {
                        pthread_mutex_lock(&s->lock);
                        s->should_exit_worker = true;
                        s->new_work_ready = true;
                        if(s->worker_waiting) {
                                pthread_cond_signal(&s->worker_cv);
                        }
                        pthread_mutex_unlock(&s->lock);
                        pthread_join(s->thread_id, NULL);
                }
 
                if (s->wav != NULL) {
                        wav_writer_close(s->wav);
                }
                if (s->ring != NULL) {
                        ring_buffer_destroy(s->ring);
                }
                pthread_cond_destroy(&s->worker_cv);
                pthread_mutex_destroy(&s->lock);
                free(s->filename);
                free(s);
        }
}

References audio_export::filename, audio_export::lock, audio_export::new_work_ready, audio_export::ring, ring_buffer_destroy(), audio_export::should_exit_worker, audio_export::thread_id, audio_export::wav, wav_writer_close(), audio_export::worker_cv, and audio_export::worker_waiting.

Referenced by disable_export().

Here is the call graph for this function:

audio_export_init()

struct audio_export * audio_export_init

(

const char *

filename

)

Definition at line 159 of file export.c.

{
        struct audio_export *s = calloc(1, sizeof(struct audio_export));
        if(!s) {
                return NULL;
        }
 
        unlink(filename);
        s->filename = strdup(filename);
        s->thread_id = 0;
        s->ring = NULL;
 
        pthread_mutex_init(&s->lock, NULL);
        pthread_cond_init(&s->worker_cv, NULL);
        s->new_work_ready = false;
        s->worker_waiting = false;
        s->should_exit_worker = false;
 
        s->saved_format = (struct audio_desc) { 0, 0, 0, 0 };
 
        return s;
}

References audio_export::filename, audio_export::lock, audio_export::new_work_ready, audio_export::ring, audio_export::saved_format, audio_export::should_exit_worker, audio_export::thread_id, audio_export::worker_cv, and audio_export::worker_waiting.

Referenced by audio_play_dump_reconfigure(), enable_export(), and reconfigure_echo().

audio_export_raw()

void audio_export_raw	(	struct audio_export *	s,
		void *	data,
		unsigned	len )

For exporting audio directly from a sample buffer. Before using this, the audio_export needs to be configured with audio_export_configure_raw()

Parameters

len	size of data in bytes

Definition at line 209 of file export.c.

                                                                       {
        assert(s->saved_format.ch_count != 0 && "Export not configured");
        pthread_mutex_lock(&s->lock);
        ring_buffer_write(s->ring, data, len);
        s->new_work_ready = true;
 
        if(s->worker_waiting) {
                pthread_cond_signal(&s->worker_cv);
        }
        pthread_mutex_unlock(&s->lock);
}

References audio_desc::ch_count, len, audio_export::lock, audio_export::new_work_ready, audio_export::ring, ring_buffer_write(), audio_export::saved_format, audio_export::worker_cv, and audio_export::worker_waiting.

Referenced by audio_export().

Here is the call graph for this function:

audio_export_raw_ch()

void audio_export_raw_ch	(	struct audio_export *	s,
		const void **	channels_data,
		unsigned	sample_count )

Export audio from separate sample buffers for each channel.

Parameters

channels_data	array of pointers to sample buffers
sample_count	number of samples to export

Definition at line 262 of file export.c.

{
        const int ch_count = s->saved_format.ch_count;
        const int bps = s->saved_format.bps;
        assert(ch_count != 0 && "Export not configured");
 
        int len = s->saved_format.ch_count * s->saved_format.bps * sample_count;
 
        pthread_mutex_lock(&s->lock);
        void *ptr1;
        int size1;
        void *ptr2;
        int size2;
        int avail = ring_get_write_regions(s->ring, len, &ptr1, &size1, &ptr2, &size2);
 
        assert((size1 % (bps * ch_count)) == 0);
        assert(!ptr2 || (size2 % (bps * ch_count)) == 0);
 
        int written = write_samples(ptr1, channels_data, bps, ch_count, size1, 0);
        if(ptr2){
                write_samples(ptr2, channels_data, bps, ch_count, size2, written);
        }
 
        ring_advance_write_idx(s->ring, avail);
 
        s->new_work_ready = true;
        if(s->worker_waiting) {
                pthread_cond_signal(&s->worker_cv);
        }
        pthread_mutex_unlock(&s->lock);
}

References audio_desc::bps, audio_desc::ch_count, len, audio_export::lock, audio_export::new_work_ready, audio_export::ring, ring_advance_write_idx(), ring_get_write_regions(), audio_export::saved_format, audio_export::worker_cv, audio_export::worker_waiting, and write_samples().

Referenced by echo_cancel().

Here is the call graph for this function:

audio_export_thread()

static void * audio_export_thread ( void * arg )

static

Definition at line 82 of file export.c.

{
        struct audio_export *s = arg;
 
        while(!s->should_exit_worker) {
                pthread_mutex_lock(&s->lock);
                while(!s->new_work_ready) {
                        s->worker_waiting = true;
                        pthread_cond_wait(&s->worker_cv, &s->lock);
                        s->worker_waiting = false;
                }
 
                int size = ring_get_current_size(s->ring);
 
                if(s->should_exit_worker && size == 0) {
                        pthread_mutex_unlock(&s->lock);
                        break;
                }
 
                char *data = malloc(size);
                assert(data);
                size_t res = ring_buffer_read(s->ring, data, size);
                assert(res == (size_t) size);
                assert(ring_get_current_size(s->ring) == 0);
                s->new_work_ready = false;
 
                pthread_mutex_unlock(&s->lock);
 
                const int sample_size = s->saved_format.bps * s->saved_format.ch_count;
                int rc = wav_writer_write(s->wav, size / sample_size, data);
                if (rc != 0) {
                        fprintf(stderr, "[Audio export] Problem writing audio samples: %s\n", ug_strerror(-rc));
                }
 
                free(data);
        }
 
        return NULL;
}

References audio_desc::bps, audio_desc::ch_count, audio_export::lock, audio_export::new_work_ready, audio_export::ring, ring_buffer_read(), ring_get_current_size(), audio_export::saved_format, audio_export::should_exit_worker, ug_strerror(), audio_export::wav, wav_writer_write(), audio_export::worker_cv, and audio_export::worker_waiting.

Referenced by audio_export(), and audio_export_configure_raw().

Here is the call graph for this function:

configure()

static bool configure ( struct audio_export * s, struct audio_desc fmt )

static

Definition at line 122 of file export.c.

                                                                     {
        s->saved_format = fmt;
 
        if ((s->wav = wav_writer_create(s->filename, fmt)) == NULL) {
                fprintf(stderr, "[Audio export] Error writting header!\n");
                return false;
        }
 
        s->ring = ring_buffer_init(CACHE_SECONDS * fmt.sample_rate * fmt.bps *
                        fmt.ch_count);
 
        return true;
}

References CACHE_SECONDS, audio_export::filename, fmt, audio_export::ring, ring_buffer_init(), audio_export::saved_format, audio_export::wav, and wav_writer_create().

Referenced by audio_export(), and audio_export_configure_raw().

Here is the call graph for this function:

write_samples()

static int write_samples ( char * out, const void ** channels_data, int bps, int ch_count, int size, int start_sample )

static

Definition at line 245 of file export.c.

{
        int written = 0;
        int in_offset = start_sample*bps;
        for(; written * bps * ch_count < size; written++){
                for(int ch = 0; ch < ch_count; ch++){
                        const char *in_ptr = ((const char *)channels_data[ch]) + in_offset;
                        memcpy(out, in_ptr, bps);
                        out += bps;
                }
                in_offset += bps;
        }
 
        return written;
}

Referenced by audio_export_raw_ch().