export.h File Reference

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

Go to the source code of this file.

Functions
void	audio_export (struct audio_export *state, 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 *state)
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)

Detailed Description

Author

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

Definition in file export.h.

Function Documentation

audio_export()

void audio_export	(	struct audio_export *	state,
		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 *

state

)

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: