You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
523 lines
13 KiB
523 lines
13 KiB
/*
|
|
This file is part of KDE/aRts (Noatun) - xine integration
|
|
Copyright (C) 2002-2003 Ewald Snel <ewald@rambo.its.tudelft.nl>
|
|
Copyright (C) 2014 Timothy Pearson <kb9vqf@pearsoncomputing.net>
|
|
|
|
This library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Lesser General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 2.1 of the License, or (at your option) any later version.
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include <config.h>
|
|
#endif
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <inttypes.h>
|
|
#include <pthread.h>
|
|
#include <time.h>
|
|
#include <sys/time.h>
|
|
#include <xine/audio_out.h>
|
|
|
|
#if (XINE_MAJOR_VERSION >= 1) && (XINE_MINOR_VERSION >= 2)
|
|
#include <xine/xine_internal.h>
|
|
#include <xine/xine_plugin.h>
|
|
#endif
|
|
|
|
#include "audio_fifo_out.h"
|
|
|
|
#define GAP_TOLERANCE 5000
|
|
|
|
// #define XINE_DEBUG 1
|
|
|
|
typedef struct fifo_driver_s {
|
|
ao_driver_t ao_driver;
|
|
|
|
xine_arts_audio *audio;
|
|
|
|
int capabilities;
|
|
int mode;
|
|
pthread_mutex_t read_mutex;
|
|
pthread_mutex_t write_mutex;
|
|
pthread_cond_t cond;
|
|
|
|
uint32_t bytes_per_frame;
|
|
uint8_t *fifo;
|
|
int fifo_size;
|
|
int fifo_read_ptr;
|
|
int fifo_write_ptr;
|
|
int fifo_flush;
|
|
int fifo_delay;
|
|
|
|
#if (XINE_MAJOR_VERSION >= 1) && (XINE_MINOR_VERSION >= 2)
|
|
config_values_t *config;
|
|
xine_t *xine;
|
|
#endif
|
|
} fifo_driver_t;
|
|
|
|
/*
|
|
* open the audio device for writing to
|
|
*/
|
|
static int ao_fifo_open( ao_driver_t *this_gen, uint32_t bits, uint32_t rate, int mode )
|
|
{
|
|
fifo_driver_t *ao = (fifo_driver_t *)this_gen;
|
|
|
|
if ((mode & ao->capabilities) == 0)
|
|
{
|
|
fprintf( stderr, "[xine_artsplugin audio_fifo_out] unsupported mode %08x\n", mode);
|
|
return 0;
|
|
}
|
|
|
|
/* lock read buffer */
|
|
pthread_mutex_lock( &ao->read_mutex );
|
|
|
|
ao->mode = mode;
|
|
ao->audio->sample_rate = rate;
|
|
ao->audio->bits_per_sample = bits;
|
|
|
|
switch (mode)
|
|
{
|
|
case AO_CAP_MODE_MONO:
|
|
ao->audio->num_channels = 1;
|
|
break;
|
|
case AO_CAP_MODE_STEREO:
|
|
ao->audio->num_channels = 2;
|
|
break;
|
|
}
|
|
|
|
ao->bytes_per_frame = (ao->audio->bits_per_sample * ao->audio->num_channels) / 8;
|
|
ao->fifo_size = ao->audio->sample_rate * ao->bytes_per_frame;
|
|
ao->fifo = malloc( 2*ao->fifo_size );
|
|
ao->fifo_read_ptr = 0;
|
|
ao->fifo_write_ptr = 0;
|
|
ao->fifo_flush = 0;
|
|
ao->fifo_delay = 0;
|
|
|
|
/* unlock and enable read buffer for aRts sound server */
|
|
pthread_mutex_unlock( &ao->read_mutex );
|
|
|
|
return ao->audio->sample_rate;
|
|
}
|
|
|
|
static int ao_fifo_num_channels( ao_driver_t *this_gen )
|
|
{
|
|
return ((fifo_driver_t *)this_gen)->audio->num_channels;
|
|
}
|
|
|
|
static int ao_fifo_bytes_per_frame( ao_driver_t *this_gen )
|
|
{
|
|
return ((fifo_driver_t *)this_gen)->bytes_per_frame;
|
|
}
|
|
|
|
static int ao_fifo_get_gap_tolerance( ao_driver_t *this_gen )
|
|
{
|
|
return GAP_TOLERANCE;
|
|
}
|
|
|
|
static int ao_fifo_bytes_in_buffer( fifo_driver_t *ao )
|
|
{
|
|
int bytes_in_buffer = (ao->fifo_write_ptr - ao->fifo_read_ptr);
|
|
|
|
if (bytes_in_buffer < 0)
|
|
{
|
|
bytes_in_buffer += ao->fifo_size;
|
|
}
|
|
return bytes_in_buffer;
|
|
}
|
|
|
|
static int ao_fifo_write( ao_driver_t *this_gen, int16_t *data, uint32_t num_frames )
|
|
{
|
|
fifo_driver_t *ao = (fifo_driver_t *)this_gen;
|
|
uint8_t *src = (uint8_t *)data;
|
|
int bytes_in_buffer, bytes_to_write, written;
|
|
|
|
bytes_to_write = (num_frames * ao->bytes_per_frame);
|
|
|
|
pthread_mutex_lock( &ao->write_mutex );
|
|
|
|
while (!ao->fifo_flush && bytes_to_write > 0)
|
|
{
|
|
bytes_in_buffer = ao_fifo_bytes_in_buffer( ao );
|
|
written = bytes_to_write;
|
|
|
|
if ((bytes_in_buffer + written) >= ao->fifo_size)
|
|
{
|
|
written = (ao->fifo_size - bytes_in_buffer - 1);
|
|
written -= (written % ao->bytes_per_frame);
|
|
|
|
if (written == 0)
|
|
{
|
|
struct timespec ts;
|
|
struct timeval tv;
|
|
int delay;
|
|
|
|
gettimeofday( &tv, 0 );
|
|
|
|
delay = ao_fifo_arts_delay();
|
|
delay += (1000 * num_frames) / ao->audio->sample_rate;
|
|
delay = (delay < 20) ? 20 : ((delay >= 250) ? 250 : delay + 1);
|
|
|
|
ts.tv_sec = tv.tv_sec + (delay / 1000);
|
|
ts.tv_nsec = (1000 * tv.tv_usec) + (1000000 * (delay % 1000));
|
|
|
|
if (ts.tv_nsec >= 1000000000)
|
|
{
|
|
ts.tv_sec++;
|
|
ts.tv_nsec -= 1000000000;
|
|
}
|
|
if (pthread_cond_timedwait( &ao->cond, &ao->write_mutex, &ts ) != 0)
|
|
{
|
|
fprintf( stderr, "[xine_artsplugin audio_fifo_out] blocked for more than %d ms,\n", delay);
|
|
fprintf( stderr, "[xine_artsplugin audio_fifo_out] %d sample(s) discarded.\n", num_frames);
|
|
pthread_mutex_unlock( &ao->write_mutex );
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!ao->fifo_flush && written > 0)
|
|
{
|
|
int new_write_ptr = (ao->fifo_write_ptr + written);
|
|
|
|
if (new_write_ptr >= ao->fifo_size)
|
|
{
|
|
new_write_ptr -= ao->fifo_size;
|
|
|
|
memcpy( &ao->fifo[ao->fifo_write_ptr], src, (written - new_write_ptr) );
|
|
memcpy( ao->fifo, &src[written - new_write_ptr], new_write_ptr );
|
|
}
|
|
else
|
|
{
|
|
memcpy( &ao->fifo[ao->fifo_write_ptr], src, written );
|
|
}
|
|
|
|
/* update audio buffer pointer */
|
|
ao->fifo_write_ptr = new_write_ptr;
|
|
bytes_to_write -= written;
|
|
src += written;
|
|
}
|
|
}
|
|
|
|
/* audio has stopped */
|
|
ao->fifo_delay += bytes_to_write;
|
|
|
|
pthread_mutex_unlock( &ao->write_mutex );
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int ao_fifo_delay( ao_driver_t *this_gen )
|
|
{
|
|
fifo_driver_t *ao = (fifo_driver_t *)this_gen;
|
|
return (ao_fifo_arts_delay() * ao->audio->sample_rate / 1000)
|
|
+ ((ao_fifo_bytes_in_buffer( ao ) + ao->fifo_delay) / ao->bytes_per_frame);
|
|
}
|
|
|
|
static void ao_fifo_close( ao_driver_t *this_gen )
|
|
{
|
|
fifo_driver_t *ao = (fifo_driver_t *)this_gen;
|
|
|
|
/* lock read buffer */
|
|
pthread_mutex_lock( &ao->read_mutex );
|
|
|
|
/* disable audio driver */
|
|
ao->fifo_flush = 2;
|
|
ao->fifo_delay = 0;
|
|
|
|
/* free audio FIFO */
|
|
if (ao->fifo)
|
|
{
|
|
free( ao->fifo );
|
|
ao->fifo = NULL;
|
|
}
|
|
pthread_mutex_unlock( &ao->read_mutex );
|
|
}
|
|
|
|
static uint32_t ao_fifo_get_capabilities( ao_driver_t *this_gen )
|
|
{
|
|
return ((fifo_driver_t *)this_gen)->capabilities;
|
|
}
|
|
|
|
static void ao_fifo_exit( ao_driver_t *this_gen )
|
|
{
|
|
fifo_driver_t *ao = (fifo_driver_t *)this_gen;
|
|
|
|
ao_fifo_close( this_gen );
|
|
|
|
pthread_cond_destroy( &ao->cond );
|
|
pthread_mutex_destroy( &ao->read_mutex );
|
|
pthread_mutex_destroy( &ao->write_mutex );
|
|
|
|
free( ao );
|
|
}
|
|
|
|
static int ao_fifo_get_property( ao_driver_t *this_gen, int property )
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static int ao_fifo_set_property( ao_driver_t *this_gen, int property, int value )
|
|
{
|
|
return ~value;
|
|
}
|
|
|
|
static int ao_fifo_control( ao_driver_t *this_gen, int cmd, ... )
|
|
{
|
|
fifo_driver_t *ao = (fifo_driver_t *)this_gen;
|
|
|
|
switch (cmd)
|
|
{
|
|
case AO_CTRL_FLUSH_BUFFERS:
|
|
case AO_CTRL_PLAY_PAUSE:
|
|
/* flush audio FIFO */
|
|
pthread_mutex_lock( &ao->read_mutex );
|
|
|
|
ao->fifo_read_ptr = ao->fifo_write_ptr;
|
|
|
|
if (ao->fifo_flush == 1)
|
|
{
|
|
ao->fifo_flush = 0;
|
|
ao->fifo_delay = 0;
|
|
}
|
|
pthread_mutex_unlock( &ao->read_mutex );
|
|
|
|
break;
|
|
|
|
case AO_CTRL_PLAY_RESUME:
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
#if (XINE_MAJOR_VERSION >= 1) && (XINE_MINOR_VERSION >= 2)
|
|
static fifo_driver_t * _ao_driver = NULL;
|
|
|
|
typedef struct fifo_class_s {
|
|
audio_driver_class_t driver_class;
|
|
config_values_t *config;
|
|
xine_t *xine;
|
|
} fifo_class_t;
|
|
|
|
static void _arts_class_dispose(audio_driver_class_t *driver_class) {
|
|
fifo_class_t *cl;
|
|
|
|
cl = (fifo_class_t *)driver_class;
|
|
free(cl);
|
|
}
|
|
|
|
static char *_arts_class_identifier_get(video_driver_class_t *driver_class) {
|
|
return "arts";
|
|
}
|
|
|
|
static char *_arts_class_description_get(video_driver_class_t *driver_class) {
|
|
return "aRts xine video output plugin";
|
|
}
|
|
|
|
static ao_driver_t * _arts_open(audio_driver_class_t *driver_class, const void *data) {
|
|
fifo_class_t *cl;
|
|
|
|
cl = (fifo_class_t *)driver_class;
|
|
|
|
_ao_driver = (fifo_driver_t *)malloc(sizeof(fifo_driver_t));
|
|
if (!_ao_driver) return NULL;
|
|
|
|
_ao_driver->config = cl->config;
|
|
_ao_driver->xine = cl->xine;
|
|
_ao_driver->audio = data;
|
|
_ao_driver->fifo = NULL;
|
|
_ao_driver->fifo_read_ptr = 0;
|
|
_ao_driver->fifo_write_ptr = 0;
|
|
_ao_driver->fifo_flush = 2;
|
|
_ao_driver->fifo_delay = 0;
|
|
_ao_driver->capabilities = (AO_CAP_MODE_MONO | AO_CAP_MODE_STEREO);
|
|
|
|
_ao_driver->ao_driver.get_capabilities = ao_fifo_get_capabilities;
|
|
_ao_driver->ao_driver.get_property = ao_fifo_get_property;
|
|
_ao_driver->ao_driver.set_property = ao_fifo_set_property;
|
|
_ao_driver->ao_driver.open = ao_fifo_open;
|
|
_ao_driver->ao_driver.num_channels = ao_fifo_num_channels;
|
|
_ao_driver->ao_driver.bytes_per_frame = ao_fifo_bytes_per_frame;
|
|
_ao_driver->ao_driver.delay = ao_fifo_delay;
|
|
_ao_driver->ao_driver.write = ao_fifo_write;
|
|
_ao_driver->ao_driver.close = ao_fifo_close;
|
|
_ao_driver->ao_driver.exit = ao_fifo_exit;
|
|
_ao_driver->ao_driver.get_gap_tolerance = ao_fifo_get_gap_tolerance;
|
|
_ao_driver->ao_driver.control = ao_fifo_control;
|
|
|
|
pthread_cond_init( &_ao_driver->cond, NULL );
|
|
pthread_mutex_init( &_ao_driver->read_mutex, NULL );
|
|
pthread_mutex_init( &_ao_driver->write_mutex, NULL );
|
|
|
|
return &_ao_driver->ao_driver;
|
|
}
|
|
|
|
static void *_arts_plugin_class_init(xine_t *xine, void *data) {
|
|
fifo_class_t *cl;
|
|
|
|
cl = (fifo_class_t *) malloc(sizeof(fifo_class_t));
|
|
if (!cl) return NULL;
|
|
cl->driver_class.open_plugin = _arts_open;
|
|
cl->driver_class.identifier = _arts_class_identifier_get(NULL);
|
|
cl->driver_class.description = _arts_class_description_get(NULL);
|
|
cl->driver_class.dispose = _arts_class_dispose;
|
|
cl->config = xine->config;
|
|
cl->xine = xine;
|
|
|
|
return cl;
|
|
}
|
|
|
|
static ao_info_t _arts_info =
|
|
{
|
|
1 /* priority */
|
|
};
|
|
|
|
plugin_info_t arts_xine_plugin_info[] =
|
|
{
|
|
{ PLUGIN_AUDIO_OUT, AUDIO_OUT_IFACE_VERSION, "arts", XINE_VERSION_CODE, &_arts_info, _arts_plugin_class_init },
|
|
{ PLUGIN_NONE, 0, "", 0, NULL, NULL }
|
|
};
|
|
#endif
|
|
|
|
xine_audio_port_t *init_audio_out_plugin( xine_t *xine, xine_arts_audio *audio,
|
|
void **ao_driver )
|
|
{
|
|
#ifdef XINE_DEBUG
|
|
xine->verbosity = 1;
|
|
#endif
|
|
|
|
#if (XINE_MAJOR_VERSION >= 1) && (XINE_MINOR_VERSION >= 2)
|
|
xine_audio_port_t *ret;
|
|
xine_register_plugins(xine, arts_xine_plugin_info);
|
|
ret = xine_open_audio_driver( xine, "arts", audio );
|
|
if (ret) {
|
|
*ao_driver = (void *)_ao_driver;
|
|
}
|
|
return ret;
|
|
#else
|
|
fifo_driver_t *ao = (fifo_driver_t *)malloc( sizeof(fifo_driver_t) );
|
|
|
|
ao->audio = audio;
|
|
ao->fifo = NULL;
|
|
ao->fifo_read_ptr = 0;
|
|
ao->fifo_write_ptr = 0;
|
|
ao->fifo_flush = 2;
|
|
ao->fifo_delay = 0;
|
|
ao->capabilities = (AO_CAP_MODE_MONO | AO_CAP_MODE_STEREO);
|
|
|
|
ao->ao_driver.get_capabilities = ao_fifo_get_capabilities;
|
|
ao->ao_driver.get_property = ao_fifo_get_property;
|
|
ao->ao_driver.set_property = ao_fifo_set_property;
|
|
ao->ao_driver.open = ao_fifo_open;
|
|
ao->ao_driver.num_channels = ao_fifo_num_channels;
|
|
ao->ao_driver.bytes_per_frame = ao_fifo_bytes_per_frame;
|
|
ao->ao_driver.delay = ao_fifo_delay;
|
|
ao->ao_driver.write = ao_fifo_write;
|
|
ao->ao_driver.close = ao_fifo_close;
|
|
ao->ao_driver.exit = ao_fifo_exit;
|
|
ao->ao_driver.get_gap_tolerance = ao_fifo_get_gap_tolerance;
|
|
ao->ao_driver.control = ao_fifo_control;
|
|
|
|
pthread_cond_init( &ao->cond, NULL );
|
|
pthread_mutex_init( &ao->read_mutex, NULL );
|
|
pthread_mutex_init( &ao->write_mutex, NULL );
|
|
|
|
*ao_driver = (void *)ao;
|
|
|
|
return ao_new_port( xine, (ao_driver_t *)ao, 0 );
|
|
#endif
|
|
}
|
|
|
|
unsigned long ao_fifo_read( void *ao_driver, unsigned char **buffer,
|
|
unsigned long samples )
|
|
{
|
|
fifo_driver_t *ao = (fifo_driver_t *)ao_driver;
|
|
int bytes_in_buffer, bytes_to_read;
|
|
|
|
/* lock read buffer */
|
|
pthread_mutex_lock( &ao->read_mutex );
|
|
|
|
bytes_in_buffer = ao_fifo_bytes_in_buffer( ao );
|
|
bytes_to_read = (samples * ao->bytes_per_frame);
|
|
|
|
if (ao->fifo_flush || bytes_in_buffer == 0)
|
|
{
|
|
/* unlock read buffer */
|
|
pthread_mutex_unlock( &ao->read_mutex );
|
|
|
|
/* signal blocked writes */
|
|
pthread_mutex_lock( &ao->write_mutex );
|
|
pthread_cond_signal( &ao->cond );
|
|
pthread_mutex_unlock( &ao->write_mutex );
|
|
|
|
/* audio FIFO empty or disabled, return */
|
|
return 0;
|
|
}
|
|
|
|
if (bytes_to_read > bytes_in_buffer)
|
|
{
|
|
fprintf( stderr, "[xine_artsplugin audio_fifo_out] audio buffer underflow!\n" );
|
|
bytes_to_read = bytes_in_buffer - (bytes_in_buffer % ao->bytes_per_frame);
|
|
}
|
|
if ((ao->fifo_read_ptr + bytes_to_read) > ao->fifo_size)
|
|
{
|
|
/* copy samples from front to end of buffer */
|
|
memcpy( &ao->fifo[ao->fifo_size], ao->fifo,
|
|
((ao->fifo_read_ptr + bytes_to_read) - ao->fifo_size) );
|
|
}
|
|
|
|
/* return pointer to audio samples */
|
|
*buffer = &ao->fifo[ao->fifo_read_ptr];
|
|
|
|
return bytes_to_read;
|
|
}
|
|
|
|
void ao_fifo_flush( void *ao_driver, unsigned long samples )
|
|
{
|
|
fifo_driver_t *ao = (fifo_driver_t *)ao_driver;
|
|
int bytes_in_buffer, bytes_to_flush;
|
|
|
|
/* flush audio data */
|
|
bytes_in_buffer = ao_fifo_bytes_in_buffer( ao );
|
|
bytes_to_flush = (samples * ao->bytes_per_frame);
|
|
|
|
if (bytes_to_flush <= bytes_in_buffer)
|
|
{
|
|
int new_read_ptr = (ao->fifo_read_ptr + bytes_to_flush);
|
|
|
|
if (new_read_ptr >= ao->fifo_size)
|
|
{
|
|
new_read_ptr -= ao->fifo_size;
|
|
}
|
|
ao->fifo_read_ptr = new_read_ptr;
|
|
}
|
|
|
|
/* unlock read buffer */
|
|
pthread_mutex_unlock( &ao->read_mutex );
|
|
|
|
/* signal blocked writes */
|
|
pthread_mutex_lock( &ao->write_mutex );
|
|
pthread_cond_signal( &ao->cond );
|
|
pthread_mutex_unlock( &ao->write_mutex );
|
|
}
|
|
|
|
void ao_fifo_clear( void *ao_driver, int clear )
|
|
{
|
|
fifo_driver_t *ao = (fifo_driver_t *)ao_driver;
|
|
|
|
pthread_mutex_lock( &ao->write_mutex );
|
|
|
|
/* enable/disable audio driver */
|
|
ao->fifo_flush = clear;
|
|
ao->fifo_delay = 0;
|
|
|
|
if (clear)
|
|
{
|
|
/* signal blocked writes */
|
|
pthread_cond_signal( &ao->cond );
|
|
}
|
|
pthread_mutex_unlock( &ao->write_mutex );
|
|
}
|