mirror of
https://github.com/mpv-player/mpv
synced 2024-09-09 01:16:56 +02:00
645 lines
18 KiB
C
645 lines
18 KiB
C
/*
|
|
* NAS audio output driver
|
|
*
|
|
* copyright (c) 2001 Tobias Diedrich <ranma@gmx.at>
|
|
*
|
|
* Based on the libaudiooss parts rewritten by me, which were
|
|
* originally based on the NAS output plugin for XMMS.
|
|
*
|
|
* XMMS plugin by Willem Monsuwe
|
|
* adapted for libaudiooss by Jon Trulson
|
|
* further modified by Erik Inge Bolsø
|
|
* largely rewritten and used for this ao driver by Tobias Diedrich
|
|
*
|
|
* This file is part of MPlayer.
|
|
*
|
|
* MPlayer 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.
|
|
*
|
|
* MPlayer 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 MPlayer; if not, write to the Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*/
|
|
|
|
/*
|
|
* Theory of operation:
|
|
*
|
|
* The NAS consists of two parts, a server daemon and a client.
|
|
* We setup the server to use a buffer of size bytes_per_second
|
|
* with a low watermark of buffer_size - NAS_FRAG_SIZE.
|
|
* Upon starting the flow the server will generate a buffer underrun
|
|
* event and the event handler will fill the buffer for the first time.
|
|
* Now the server will generate a lowwater event when the server buffer
|
|
* falls below the low watermark value. The event handler gets called
|
|
* again and refills the buffer by the number of bytes requested by the
|
|
* server (usually a multiple of 4096). To prevent stuttering on
|
|
* startup (start of playing, seeks, unpausing) the client buffer should
|
|
* be bigger than the server buffer. (For debugging we also do some
|
|
* accounting of what we think how much of the server buffer is filled)
|
|
*/
|
|
|
|
#include <unistd.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <pthread.h>
|
|
#include <limits.h>
|
|
#include <audio/audiolib.h>
|
|
|
|
#include "config.h"
|
|
#include "mp_msg.h"
|
|
|
|
#include "audio_out.h"
|
|
#include "audio_out_internal.h"
|
|
#include "libaf/af_format.h"
|
|
|
|
/* NAS_FRAG_SIZE must be a power-of-two value */
|
|
#define NAS_FRAG_SIZE 4096
|
|
|
|
static const char * const nas_event_types[] = {
|
|
"Undefined",
|
|
"Undefined",
|
|
"ElementNotify",
|
|
"GrabNotify",
|
|
"MonitorNotify",
|
|
"BucketNotify",
|
|
"DeviceNotify"
|
|
};
|
|
|
|
static const char * const nas_elementnotify_kinds[] = {
|
|
"LowWater",
|
|
"HighWater",
|
|
"State",
|
|
"Unknown"
|
|
};
|
|
|
|
static const char * const nas_states[] = {
|
|
"Stop",
|
|
"Start",
|
|
"Pause",
|
|
"Any"
|
|
};
|
|
|
|
static const char * const nas_reasons[] = {
|
|
"User",
|
|
"Underrun",
|
|
"Overrun",
|
|
"EOF",
|
|
"Watermark",
|
|
"Hardware",
|
|
"Any"
|
|
};
|
|
|
|
static const char* nas_reason(unsigned int reason)
|
|
{
|
|
if (reason > 6) reason = 6;
|
|
return nas_reasons[reason];
|
|
}
|
|
|
|
static const char* nas_elementnotify_kind(unsigned int kind)
|
|
{
|
|
if (kind > 2) kind = 3;
|
|
return nas_elementnotify_kinds[kind];
|
|
}
|
|
|
|
static const char* nas_event_type(unsigned int type) {
|
|
if (type > 6) type = 0;
|
|
return nas_event_types[type];
|
|
}
|
|
|
|
static const char* nas_state(unsigned int state) {
|
|
if (state>3) state = 3;
|
|
return nas_states[state];
|
|
}
|
|
|
|
static const ao_info_t info =
|
|
{
|
|
"NAS audio output",
|
|
"nas",
|
|
"Tobias Diedrich <ranma+mplayer@tdiedrich.de>",
|
|
""
|
|
};
|
|
|
|
struct ao_nas_data {
|
|
AuServer *aud;
|
|
AuFlowID flow;
|
|
AuDeviceID dev;
|
|
AuFixedPoint gain;
|
|
|
|
unsigned int state;
|
|
int expect_underrun;
|
|
|
|
char *client_buffer;
|
|
char *server_buffer;
|
|
unsigned int client_buffer_size;
|
|
unsigned int client_buffer_used;
|
|
unsigned int server_buffer_size;
|
|
unsigned int server_buffer_used;
|
|
pthread_mutex_t buffer_mutex;
|
|
|
|
pthread_t event_thread;
|
|
int stop_thread;
|
|
};
|
|
|
|
static struct ao_nas_data *nas_data;
|
|
|
|
LIBAO_EXTERN(nas)
|
|
|
|
static void nas_print_error(AuServer *aud, const char *prefix, AuStatus as)
|
|
{
|
|
char s[100];
|
|
AuGetErrorText(aud, as, s, 100);
|
|
mp_msg(MSGT_AO, MSGL_ERR, "ao_nas: %s: returned status %d (%s)\n", prefix, as, s);
|
|
}
|
|
|
|
static int nas_readBuffer(struct ao_nas_data *nas_data, unsigned int num)
|
|
{
|
|
AuStatus as;
|
|
|
|
pthread_mutex_lock(&nas_data->buffer_mutex);
|
|
mp_msg(MSGT_AO, MSGL_DBG2, "ao_nas: nas_readBuffer(): num=%d client=%d/%d server=%d/%d\n",
|
|
num,
|
|
nas_data->client_buffer_used, nas_data->client_buffer_size,
|
|
nas_data->server_buffer_used, nas_data->server_buffer_size);
|
|
|
|
if (nas_data->client_buffer_used == 0) {
|
|
mp_msg(MSGT_AO, MSGL_DBG2, "ao_nas: buffer is empty, nothing read.\n");
|
|
pthread_mutex_unlock(&nas_data->buffer_mutex);
|
|
return 0;
|
|
}
|
|
if (num > nas_data->client_buffer_used)
|
|
num = nas_data->client_buffer_used;
|
|
|
|
/*
|
|
* It is not appropriate to call AuWriteElement() here because the
|
|
* buffer is locked and delays writing to the network will cause
|
|
* other threads to block waiting for buffer_mutex. Instead the
|
|
* data is copied to "server_buffer" and written to the network
|
|
* outside of the locked section of code.
|
|
*
|
|
* (Note: Rather than these two buffers, a single circular buffer
|
|
* could eliminate the memcpy/memmove steps.)
|
|
*/
|
|
/* make sure we don't overflow the buffer */
|
|
if (num > nas_data->server_buffer_size)
|
|
num = nas_data->server_buffer_size;
|
|
memcpy(nas_data->server_buffer, nas_data->client_buffer, num);
|
|
|
|
nas_data->client_buffer_used -= num;
|
|
nas_data->server_buffer_used += num;
|
|
memmove(nas_data->client_buffer, nas_data->client_buffer + num, nas_data->client_buffer_used);
|
|
pthread_mutex_unlock(&nas_data->buffer_mutex);
|
|
|
|
/*
|
|
* Now write the new buffer to the network.
|
|
*/
|
|
AuWriteElement(nas_data->aud, nas_data->flow, 0, num, nas_data->server_buffer, AuFalse, &as);
|
|
if (as != AuSuccess)
|
|
nas_print_error(nas_data->aud, "nas_readBuffer(): AuWriteElement", as);
|
|
|
|
return num;
|
|
}
|
|
|
|
static int nas_writeBuffer(struct ao_nas_data *nas_data, void *data, unsigned int len)
|
|
{
|
|
pthread_mutex_lock(&nas_data->buffer_mutex);
|
|
mp_msg(MSGT_AO, MSGL_DBG2, "ao_nas: nas_writeBuffer(): len=%d client=%d/%d server=%d/%d\n",
|
|
len, nas_data->client_buffer_used, nas_data->client_buffer_size,
|
|
nas_data->server_buffer_used, nas_data->server_buffer_size);
|
|
|
|
/* make sure we don't overflow the buffer */
|
|
if (len > nas_data->client_buffer_size - nas_data->client_buffer_used)
|
|
len = nas_data->client_buffer_size - nas_data->client_buffer_used;
|
|
memcpy(nas_data->client_buffer + nas_data->client_buffer_used, data, len);
|
|
nas_data->client_buffer_used += len;
|
|
|
|
pthread_mutex_unlock(&nas_data->buffer_mutex);
|
|
|
|
return len;
|
|
}
|
|
|
|
static int nas_empty_event_queue(struct ao_nas_data *nas_data)
|
|
{
|
|
AuEvent ev;
|
|
int result = 0;
|
|
|
|
while (AuScanForTypedEvent(nas_data->aud, AuEventsQueuedAfterFlush,
|
|
AuTrue, AuEventTypeElementNotify, &ev)) {
|
|
AuDispatchEvent(nas_data->aud, &ev);
|
|
result = 1;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static void *nas_event_thread_start(void *data)
|
|
{
|
|
struct ao_nas_data *nas_data = data;
|
|
|
|
do {
|
|
mp_msg(MSGT_AO, MSGL_DBG2,
|
|
"ao_nas: event thread heartbeat (state=%s)\n",
|
|
nas_state(nas_data->state));
|
|
nas_empty_event_queue(nas_data);
|
|
usleep(1000);
|
|
} while (!nas_data->stop_thread);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static AuBool nas_error_handler(AuServer* aud, AuErrorEvent* ev)
|
|
{
|
|
char s[100];
|
|
AuGetErrorText(aud, ev->error_code, s, 100);
|
|
mp_msg(MSGT_AO, MSGL_ERR, "ao_nas: error [%s]\n"
|
|
"error_code: %d\n"
|
|
"request_code: %d\n"
|
|
"minor_code: %d\n",
|
|
s,
|
|
ev->error_code,
|
|
ev->request_code,
|
|
ev->minor_code);
|
|
|
|
return AuTrue;
|
|
}
|
|
|
|
static AuBool nas_event_handler(AuServer *aud, AuEvent *ev, AuEventHandlerRec *hnd)
|
|
{
|
|
AuElementNotifyEvent *event = (AuElementNotifyEvent *) ev;
|
|
struct ao_nas_data *nas_data = hnd->data;
|
|
|
|
mp_msg(MSGT_AO, MSGL_DBG2, "ao_nas: event_handler(): type %s kind %s state %s->%s reason %s numbytes %d expect_underrun %d\n",
|
|
nas_event_type(event->type),
|
|
nas_elementnotify_kind(event->kind),
|
|
nas_state(event->prev_state),
|
|
nas_state(event->cur_state),
|
|
nas_reason(event->reason),
|
|
(int)event->num_bytes,
|
|
nas_data->expect_underrun);
|
|
|
|
if (event->num_bytes > INT_MAX) {
|
|
mp_msg(MSGT_AO, MSGL_ERR, "ao_nas: num_bytes > 2GB, server buggy?\n");
|
|
}
|
|
|
|
if (event->num_bytes > nas_data->server_buffer_used)
|
|
event->num_bytes = nas_data->server_buffer_used;
|
|
nas_data->server_buffer_used -= event->num_bytes;
|
|
|
|
switch (event->reason) {
|
|
case AuReasonWatermark:
|
|
nas_readBuffer(nas_data, event->num_bytes);
|
|
break;
|
|
case AuReasonUnderrun:
|
|
// buffer underrun -> refill buffer
|
|
nas_data->server_buffer_used = 0;
|
|
if (nas_data->expect_underrun) {
|
|
nas_data->expect_underrun = 0;
|
|
} else {
|
|
static int hint = 1;
|
|
mp_msg(MSGT_AO, MSGL_WARN,
|
|
"ao_nas: Buffer underrun.\n");
|
|
if (hint) {
|
|
hint = 0;
|
|
mp_msg(MSGT_AO, MSGL_HINT,
|
|
"Possible reasons are:\n"
|
|
"1) Network congestion.\n"
|
|
"2) Your NAS server is too slow.\n"
|
|
"Try renicing your nasd to e.g. -15.\n");
|
|
}
|
|
}
|
|
if (nas_readBuffer(nas_data,
|
|
nas_data->server_buffer_size -
|
|
nas_data->server_buffer_used) != 0) {
|
|
event->cur_state = AuStateStart;
|
|
break;
|
|
}
|
|
mp_msg(MSGT_AO, MSGL_DBG2,
|
|
"ao_nas: Can't refill buffer, stopping flow.\n");
|
|
AuStopFlow(aud, nas_data->flow, NULL);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
nas_data->state=event->cur_state;
|
|
return AuTrue;
|
|
}
|
|
|
|
static AuDeviceID nas_find_device(AuServer *aud, int nch)
|
|
{
|
|
int i;
|
|
for (i = 0; i < AuServerNumDevices(aud); i++) {
|
|
AuDeviceAttributes *dev = AuServerDevice(aud, i);
|
|
if ((AuDeviceKind(dev) == AuComponentKindPhysicalOutput) &&
|
|
AuDeviceNumTracks(dev) == nch) {
|
|
return AuDeviceIdentifier(dev);
|
|
}
|
|
}
|
|
return AuNone;
|
|
}
|
|
|
|
static unsigned int nas_aformat_to_auformat(unsigned int *format)
|
|
{
|
|
switch (*format) {
|
|
case AF_FORMAT_U8:
|
|
return AuFormatLinearUnsigned8;
|
|
case AF_FORMAT_S8:
|
|
return AuFormatLinearSigned8;
|
|
case AF_FORMAT_U16_LE:
|
|
return AuFormatLinearUnsigned16LSB;
|
|
case AF_FORMAT_U16_BE:
|
|
return AuFormatLinearUnsigned16MSB;
|
|
case AF_FORMAT_S16_LE:
|
|
return AuFormatLinearSigned16LSB;
|
|
case AF_FORMAT_S16_BE:
|
|
return AuFormatLinearSigned16MSB;
|
|
case AF_FORMAT_MU_LAW:
|
|
return AuFormatULAW8;
|
|
default:
|
|
*format=AF_FORMAT_S16_NE;
|
|
return nas_aformat_to_auformat(format);
|
|
}
|
|
}
|
|
|
|
// to set/get/query special features/parameters
|
|
static int control(int cmd, void *arg)
|
|
{
|
|
AuElementParameters aep;
|
|
AuStatus as;
|
|
int retval = CONTROL_UNKNOWN;
|
|
|
|
ao_control_vol_t *vol = (ao_control_vol_t *)arg;
|
|
|
|
switch (cmd) {
|
|
case AOCONTROL_GET_VOLUME:
|
|
|
|
vol->right = (float)nas_data->gain/AU_FIXED_POINT_SCALE*50;
|
|
vol->left = vol->right;
|
|
|
|
mp_msg(MSGT_AO, MSGL_DBG2, "ao_nas: AOCONTROL_GET_VOLUME: %.2f\n", vol->right);
|
|
retval = CONTROL_OK;
|
|
break;
|
|
|
|
case AOCONTROL_SET_VOLUME:
|
|
/*
|
|
* kn: we should have vol->left == vol->right but i don't
|
|
* know if something can change it outside of ao_nas
|
|
* so i take the mean of both values.
|
|
*/
|
|
nas_data->gain = AU_FIXED_POINT_SCALE*((vol->left+vol->right)/2)/50;
|
|
mp_msg(MSGT_AO, MSGL_DBG2, "ao_nas: AOCONTROL_SET_VOLUME: %.2f\n", (vol->left+vol->right)/2);
|
|
|
|
aep.parameters[AuParmsMultiplyConstantConstant]=nas_data->gain;
|
|
aep.flow = nas_data->flow;
|
|
aep.element_num = 1;
|
|
aep.num_parameters = AuParmsMultiplyConstant;
|
|
|
|
AuSetElementParameters(nas_data->aud, 1, &aep, &as);
|
|
if (as != AuSuccess) {
|
|
nas_print_error(nas_data->aud,
|
|
"control(): AuSetElementParameters", as);
|
|
retval = CONTROL_ERROR;
|
|
} else retval = CONTROL_OK;
|
|
break;
|
|
};
|
|
|
|
return retval;
|
|
}
|
|
|
|
// open & setup audio device
|
|
// return: 1=success 0=fail
|
|
static int init(int rate,int channels,int format,int flags)
|
|
{
|
|
AuElement elms[3];
|
|
AuStatus as;
|
|
unsigned char auformat = nas_aformat_to_auformat(&format);
|
|
int bytes_per_sample = channels * AuSizeofFormat(auformat);
|
|
int buffer_size;
|
|
char *server;
|
|
|
|
(void)flags; /* shut up 'unused parameter' warning */
|
|
|
|
nas_data=malloc(sizeof(struct ao_nas_data));
|
|
memset(nas_data, 0, sizeof(struct ao_nas_data));
|
|
|
|
mp_msg(MSGT_AO, MSGL_V, "ao2: %d Hz %d chans %s\n",rate,channels,
|
|
af_fmt2str_short(format));
|
|
|
|
ao_data.format = format;
|
|
ao_data.samplerate = rate;
|
|
ao_data.channels = channels;
|
|
ao_data.outburst = NAS_FRAG_SIZE;
|
|
ao_data.bps = rate * bytes_per_sample;
|
|
buffer_size = ao_data.bps; /* buffer 1 second */
|
|
/*
|
|
* round up to multiple of NAS_FRAG_SIZE
|
|
* divide by 3 first because of 2:1 split
|
|
*/
|
|
buffer_size = (buffer_size/3 + NAS_FRAG_SIZE-1) & ~(NAS_FRAG_SIZE-1);
|
|
ao_data.buffersize = buffer_size*3;
|
|
|
|
nas_data->client_buffer_size = buffer_size*2;
|
|
nas_data->client_buffer = malloc(nas_data->client_buffer_size);
|
|
nas_data->server_buffer_size = buffer_size;
|
|
nas_data->server_buffer = malloc(nas_data->server_buffer_size);
|
|
|
|
if (!bytes_per_sample) {
|
|
mp_msg(MSGT_AO, MSGL_ERR, "ao_nas: init(): Zero bytes per sample -> nosound\n");
|
|
return 0;
|
|
}
|
|
|
|
if (!(server = getenv("AUDIOSERVER")) &&
|
|
!(server = getenv("DISPLAY"))) {
|
|
mp_msg(MSGT_AO, MSGL_ERR, "ao_nas: init(): AUDIOSERVER environment variable not set -> nosound\n");
|
|
return 0;
|
|
}
|
|
|
|
mp_msg(MSGT_AO, MSGL_V, "ao_nas: init(): Using audioserver %s\n", server);
|
|
|
|
nas_data->aud = AuOpenServer(server, 0, NULL, 0, NULL, NULL);
|
|
if (!nas_data->aud) {
|
|
mp_msg(MSGT_AO, MSGL_ERR, "ao_nas: init(): Can't open nas audio server -> nosound\n");
|
|
return 0;
|
|
}
|
|
|
|
while (channels>0) {
|
|
nas_data->dev = nas_find_device(nas_data->aud, channels);
|
|
if (nas_data->dev != AuNone &&
|
|
((nas_data->flow = AuCreateFlow(nas_data->aud, NULL)) != 0))
|
|
break;
|
|
channels--;
|
|
}
|
|
|
|
if (nas_data->flow == 0) {
|
|
mp_msg(MSGT_AO, MSGL_ERR, "ao_nas: init(): Can't find a suitable output device -> nosound\n");
|
|
AuCloseServer(nas_data->aud);
|
|
nas_data->aud = 0;
|
|
return 0;
|
|
}
|
|
|
|
AuMakeElementImportClient(elms, rate, auformat, channels, AuTrue,
|
|
buffer_size / bytes_per_sample,
|
|
(buffer_size - NAS_FRAG_SIZE) /
|
|
bytes_per_sample, 0, NULL);
|
|
nas_data->gain = AuFixedPointFromFraction(1, 1);
|
|
AuMakeElementMultiplyConstant(elms+1, 0, nas_data->gain);
|
|
AuMakeElementExportDevice(elms+2, 1, nas_data->dev, rate,
|
|
AuUnlimitedSamples, 0, NULL);
|
|
AuSetElements(nas_data->aud, nas_data->flow, AuTrue, sizeof(elms)/sizeof(*elms), elms, &as);
|
|
if (as != AuSuccess) {
|
|
nas_print_error(nas_data->aud, "init(): AuSetElements", as);
|
|
AuCloseServer(nas_data->aud);
|
|
nas_data->aud = 0;
|
|
return 0;
|
|
}
|
|
AuRegisterEventHandler(nas_data->aud, AuEventHandlerIDMask |
|
|
AuEventHandlerTypeMask,
|
|
AuEventTypeElementNotify, nas_data->flow,
|
|
nas_event_handler, (AuPointer) nas_data);
|
|
AuSetErrorHandler(nas_data->aud, nas_error_handler);
|
|
nas_data->state=AuStateStop;
|
|
nas_data->expect_underrun=0;
|
|
|
|
pthread_mutex_init(&nas_data->buffer_mutex, NULL);
|
|
pthread_create(&nas_data->event_thread, NULL, &nas_event_thread_start, nas_data);
|
|
|
|
return 1;
|
|
}
|
|
|
|
// close audio device
|
|
static void uninit(int immed){
|
|
|
|
mp_msg(MSGT_AO, MSGL_DBG3, "ao_nas: uninit()\n");
|
|
|
|
nas_data->expect_underrun = 1;
|
|
if (!immed)
|
|
while (nas_data->state != AuStateStop) usleep(1000);
|
|
nas_data->stop_thread = 1;
|
|
pthread_join(nas_data->event_thread, NULL);
|
|
AuCloseServer(nas_data->aud);
|
|
nas_data->aud = 0;
|
|
free(nas_data->client_buffer);
|
|
free(nas_data->server_buffer);
|
|
}
|
|
|
|
// stop playing and empty buffers (for seeking/pause)
|
|
static void reset(void){
|
|
AuStatus as;
|
|
|
|
mp_msg(MSGT_AO, MSGL_DBG3, "ao_nas: reset()\n");
|
|
|
|
pthread_mutex_lock(&nas_data->buffer_mutex);
|
|
nas_data->client_buffer_used = 0;
|
|
pthread_mutex_unlock(&nas_data->buffer_mutex);
|
|
while (nas_data->state != AuStateStop) {
|
|
AuStopFlow(nas_data->aud, nas_data->flow, &as);
|
|
if (as != AuSuccess)
|
|
nas_print_error(nas_data->aud, "reset(): AuStopFlow", as);
|
|
usleep(1000);
|
|
}
|
|
}
|
|
|
|
// stop playing, keep buffers (for pause)
|
|
static void audio_pause(void)
|
|
{
|
|
AuStatus as;
|
|
mp_msg(MSGT_AO, MSGL_DBG3, "ao_nas: audio_pause()\n");
|
|
|
|
AuStopFlow(nas_data->aud, nas_data->flow, &as);
|
|
}
|
|
|
|
// resume playing, after audio_pause()
|
|
static void audio_resume(void)
|
|
{
|
|
AuStatus as;
|
|
|
|
mp_msg(MSGT_AO, MSGL_DBG3, "ao_nas: audio_resume()\n");
|
|
|
|
AuStartFlow(nas_data->aud, nas_data->flow, &as);
|
|
if (as != AuSuccess)
|
|
nas_print_error(nas_data->aud,
|
|
"play(): AuStartFlow", as);
|
|
}
|
|
|
|
|
|
// return: how many bytes can be played without blocking
|
|
static int get_space(void)
|
|
{
|
|
int result;
|
|
|
|
mp_msg(MSGT_AO, MSGL_DBG3, "ao_nas: get_space()\n");
|
|
|
|
pthread_mutex_lock(&nas_data->buffer_mutex);
|
|
result = nas_data->client_buffer_size - nas_data->client_buffer_used;
|
|
pthread_mutex_unlock(&nas_data->buffer_mutex);
|
|
|
|
return result;
|
|
}
|
|
|
|
// plays 'len' bytes of 'data'
|
|
// it should round it down to outburst*n
|
|
// return: number of bytes played
|
|
static int play(void* data,int len,int flags)
|
|
{
|
|
int written, maxbursts = 0, playbursts = 0;
|
|
AuStatus as;
|
|
|
|
mp_msg(MSGT_AO, MSGL_DBG3,
|
|
"ao_nas: play(%p, %d, %d)\n",
|
|
data, len, flags);
|
|
|
|
if (len == 0)
|
|
return 0;
|
|
|
|
if (!(flags & AOPLAY_FINAL_CHUNK)) {
|
|
pthread_mutex_lock(&nas_data->buffer_mutex);
|
|
maxbursts = (nas_data->client_buffer_size -
|
|
nas_data->client_buffer_used) / ao_data.outburst;
|
|
playbursts = len / ao_data.outburst;
|
|
len = (playbursts > maxbursts ? maxbursts : playbursts) *
|
|
ao_data.outburst;
|
|
pthread_mutex_unlock(&nas_data->buffer_mutex);
|
|
}
|
|
|
|
/*
|
|
* If AOPLAY_FINAL_CHUNK is set, we did not actually check len fits
|
|
* into the available buffer space, but mplayer.c shouldn't give us
|
|
* more to play than we report to it by get_space(), so this should be
|
|
* fine.
|
|
*/
|
|
written = nas_writeBuffer(nas_data, data, len);
|
|
|
|
if (nas_data->state != AuStateStart &&
|
|
(maxbursts == playbursts ||
|
|
flags & AOPLAY_FINAL_CHUNK)) {
|
|
mp_msg(MSGT_AO, MSGL_DBG2, "ao_nas: play(): Starting flow.\n");
|
|
nas_data->expect_underrun = 1;
|
|
AuStartFlow(nas_data->aud, nas_data->flow, &as);
|
|
if (as != AuSuccess)
|
|
nas_print_error(nas_data->aud, "play(): AuStartFlow", as);
|
|
}
|
|
|
|
return written;
|
|
}
|
|
|
|
// return: delay in seconds between first and last sample in buffer
|
|
static float get_delay(void)
|
|
{
|
|
float result;
|
|
|
|
mp_msg(MSGT_AO, MSGL_DBG3, "ao_nas: get_delay()\n");
|
|
|
|
pthread_mutex_lock(&nas_data->buffer_mutex);
|
|
result = ((float)(nas_data->client_buffer_used +
|
|
nas_data->server_buffer_used)) /
|
|
(float)ao_data.bps;
|
|
pthread_mutex_unlock(&nas_data->buffer_mutex);
|
|
|
|
return result;
|
|
}
|