audio_loopback.c

Go to the documentation of this file.

/*
 * audio_loopback.c
 * $Id: audio_loopback.c,v 1.5 2009/05/30 00:45:51 kprox Exp $
 *
 * Copyright (C) 2005:
 * Ken Prox <kprox@users.sourceforge.net>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <pthread.h>
#include <stdint.h>
#include <semaphore.h>
#include "audio_loopback.h"

#include "utility.h"

/*
 * Private types
 */

typedef enum audio_loopback_thread_state_te {
    AUDIO_LOOPBACK_STOP,
    AUDIO_LOOPBACK_RUN
} audio_loopback_thread_state_te;   

typedef struct audio_loopback_ts {
    p_audio_device                      audio_device;
    audio_loopback_thread_state_te      run;
    double                              *audio_data;
    uint32_t                            dst_samples;
    uint32_t                            src_samples;
    pthread_t                           play_id;
    pthread_t                           convert_id;
} audio_loopback_ts;   

/*
 * Private Date
 */

static audio_loopback_ts                loopback;
static pthread_cond_t                   write_segment_cond[AUDIO_BUFFER_SEGMENTS] = {PTHREAD_COND_INITIALIZER, PTHREAD_COND_INITIALIZER};
static pthread_mutex_t                  write_segment_mutex[AUDIO_BUFFER_SEGMENTS] = {PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER};
static sem_t                            loopback_trigger;


/*
 * Private Functions
 */
static void audio_loopback_thr(void *param);
static void audio_loopback_convert_thr(void *param);
static void audio_loopback_trigger(void);

/*
 * Implementation
 */
int32_t audio_loopback_start(te_audio_device_types device_type,
                             const char *device_name,
                             uint32_t segment_size,
                             int32_t sample_frequency)
{
    loopback.audio_data = NULL;
    if(NULL != (loopback.audio_device = audio_create(device_type,
                                                     AUDIO_DEVICE_PLAY,
                                                     device_name,
                                                     sample_frequency))) {
        audio_open(loopback.audio_device);
        audio_init(loopback.audio_device);
        loopback.dst_samples = audio_device_samples_get(loopback.audio_device);
        loopback.src_samples = segment_size;
        loopback.audio_data = malloc((size_t)(AUDIO_BUFFER_SEGMENTS * loopback.dst_samples * sizeof(double)));
        loopback.run = AUDIO_LOOPBACK_RUN;
        sem_init(&loopback_trigger, 0, 0);
        (void)pthread_create(&loopback.play_id, NULL, (void*)&audio_loopback_thr, NULL);
        (void)pthread_create(&loopback.convert_id, NULL, (void*)&audio_loopback_convert_thr, NULL);
    }        
    return 0;
}

static void audio_loopback_trigger(void)
{
    (void)sem_post(&loopback_trigger);
}

int32_t audio_loopback_stop(void)
{
    loopback.run = AUDIO_LOOPBACK_STOP;
    pthread_join(loopback.convert_id, NULL);
    pthread_join(loopback.play_id, NULL);
    free(loopback.audio_data);
    loopback.audio_data = NULL;
    (void)audio_destroy(&loopback.audio_device);
    return 0;
}

void audio_loopback_feed(const double *src)
{
    double *dst;
    static te_audio_segments buffer_segment = BUFFER_SEGMENT_1;
    
    if(NULL != loopback.audio_data) {
        dst = &loopback.audio_data[buffer_segment * loopback.dst_samples];
        memcpy(dst, src, loopback.dst_samples);
        pthread_cond_signal(&write_segment_cond[buffer_segment]);
        buffer_segment++;
        if(buffer_segment >= AUDIO_BUFFER_SEGMENTS) {
            buffer_segment = BUFFER_SEGMENT_1;
        }
    }        
}    

static void audio_loopback_thr(void *param)
{
    static te_audio_segments buffer_segment;
    static int32_t triggered = 0;

    buffer_segment = BUFFER_SEGMENT_1;
    while(loopback.run == AUDIO_LOOPBACK_RUN) {
        if(triggered == 0) {
            (void)sem_wait(&loopback_trigger);
            triggered = 1;
        }                        
        audio_play(loopback.audio_device, buffer_segment);
        buffer_segment++;
        if(buffer_segment >= AUDIO_BUFFER_SEGMENTS) {
            buffer_segment = BUFFER_SEGMENT_1;
        }
    }
    pthread_cond_signal(&write_segment_cond[0]);
    pthread_cond_signal(&write_segment_cond[1]);
    pthread_exit(NULL);
}

static void audio_loopback_convert_thr(void *param)
{
    static te_audio_segments buffer_segment;
    double *audio_data;

    buffer_segment = BUFFER_SEGMENT_1;
    while(loopback.run == AUDIO_LOOPBACK_RUN) {
        pthread_cond_wait(&write_segment_cond[buffer_segment], &write_segment_mutex[buffer_segment]);

        audio_data = &loopback.audio_data[buffer_segment * loopback.dst_samples];
        
        audio_double2raw(loopback.audio_device, buffer_segment, audio_data);
        audio_loopback_trigger();
        pthread_mutex_unlock(&write_segment_mutex[buffer_segment]);
        buffer_segment++;
        if(buffer_segment >= AUDIO_BUFFER_SEGMENTS) {
            buffer_segment = BUFFER_SEGMENT_1;
        }
    }
    pthread_exit(NULL);
}

---