2014-03-07 14:24:32 +00:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef MP_AO_INTERNAL_H_
|
|
|
|
#define MP_AO_INTERNAL_H_
|
|
|
|
|
2014-03-08 23:04:37 +00:00
|
|
|
#include <stdbool.h>
|
|
|
|
|
|
|
|
#include "audio/chmap.h"
|
|
|
|
#include "audio/chmap_sel.h"
|
|
|
|
|
audio/out: reduce amount of audio buffering
Since the addition of the AO feed thread, 200ms of latency (MIN_BUFFER)
was added to all push-based AOs. This is not so nice, because even AOs
with relatively small buffering (e.g. ao_alsa on my system with ~170ms
of buffer size), the additional latency becomes noticable when e.g.
toggling mute with softvol.
Fix this by trying to keep not only 200ms minimum buffer, but also 200ms
maximum buffer. In other words, never buffer beyond 200ms in total. Do
this by estimating the AO's buffer fill status using get_space and the
initially known AO buffer size (the get_space return value on
initialization, before any audio was played). We limit the maximum
amount of data written to the soft buffer so that soft buffer size and
audio buffer size equal to 200ms (MIN_BUFFER).
To avoid weird problems with weird AOs, we buffer beyond MIN_BUFFER if
the AO's get_space requests more data than that, and as long as the soft
buffer is large enough.
Note that this is just a hack to improve the latency. When the audio
chain gains the ability to refilter data, this won't be needed anymore,
and instead we can introduce some sort of buffer replacement function in
order to update data in the soft buffer.
2014-03-10 00:13:40 +00:00
|
|
|
// Minimum buffer size in seconds.
|
|
|
|
#define MIN_BUFFER 0.2
|
|
|
|
|
2014-04-17 21:48:09 +00:00
|
|
|
// If ao_get_delay() reaches this value after ao_play() was called with the
|
|
|
|
// AOPLAY_FINAL_CHUNK flag set, the playback core expects that the audio has
|
|
|
|
// all been played.
|
|
|
|
#define AO_EOF_DELAY 0.05
|
|
|
|
|
2014-03-07 14:24:32 +00:00
|
|
|
/* global data used by ao.c and ao drivers */
|
|
|
|
struct ao {
|
|
|
|
int samplerate;
|
|
|
|
struct mp_chmap channels;
|
|
|
|
int format; // one of AF_FORMAT_...
|
2014-03-08 23:04:37 +00:00
|
|
|
int bps; // bytes per second (per plane)
|
2014-03-07 14:24:32 +00:00
|
|
|
int sstride; // size of a sample on each plane
|
|
|
|
// (format_size*num_channels/num_planes)
|
2014-03-08 23:04:37 +00:00
|
|
|
int num_planes;
|
2014-03-07 14:24:32 +00:00
|
|
|
bool probing; // if true, don't fail loudly on init
|
|
|
|
bool untimed; // don't assume realtime playback
|
|
|
|
bool no_persistent_volume; // the AO does the equivalent of af_volume
|
|
|
|
bool per_application_mixer; // like above, but volume persists (per app)
|
2014-03-08 23:04:37 +00:00
|
|
|
int device_buffer; // device buffer in samples (guessed by
|
|
|
|
// common init code if not set by driver)
|
|
|
|
const struct ao_driver *api; // entrypoints to the wrapper (push.c/pull.c)
|
2014-03-07 14:24:32 +00:00
|
|
|
const struct ao_driver *driver;
|
|
|
|
void *priv;
|
|
|
|
struct encode_lavc_context *encode_lavc_ctx;
|
|
|
|
struct input_ctx *input_ctx;
|
|
|
|
struct mp_log *log; // Using e.g. "[ao/coreaudio]" as prefix
|
2014-03-08 23:04:37 +00:00
|
|
|
|
|
|
|
int buffer;
|
|
|
|
void *api_priv;
|
2014-03-07 14:24:32 +00:00
|
|
|
};
|
|
|
|
|
2014-03-08 23:04:37 +00:00
|
|
|
extern const struct ao_driver ao_api_push;
|
|
|
|
extern const struct ao_driver ao_api_pull;
|
|
|
|
|
|
|
|
|
|
|
|
/* Note:
|
|
|
|
*
|
|
|
|
* In general, there are two types of audio drivers:
|
|
|
|
* a) push based (the user queues data that should be played)
|
|
|
|
* b) pull callback based (the audio API calls a callback to get audio)
|
|
|
|
*
|
|
|
|
* The ao.c code can handle both. It basically implements two audio paths
|
|
|
|
* and provides a uniform API for them. If ao_driver->play is NULL, it assumes
|
|
|
|
* that the driver uses a callback based audio API, otherwise push based.
|
|
|
|
*
|
|
|
|
* Requirements:
|
|
|
|
* a) Most functions (except ->control) must be provided. ->play is called to
|
|
|
|
* queue audio. ao.c creates a thread to regularly refill audio device
|
|
|
|
* buffers with ->play, but all driver functions are always called under
|
|
|
|
* an exclusive lock.
|
|
|
|
* Mandatory:
|
|
|
|
* init
|
|
|
|
* uninit
|
|
|
|
* reset
|
|
|
|
* get_space
|
|
|
|
* play
|
|
|
|
* get_delay
|
|
|
|
* pause
|
|
|
|
* resume
|
audio/out/pull: remove race conditions
There were subtle and minor race conditions in the pull.c code, and AOs
using it (jack, portaudio, sdl, wasapi). Attempt to remove these.
There was at least a race condition in the ao_reset() implementation:
mp_ring_reset() was called concurrently to the audio callback. While the
ringbuffer uses atomics to allow concurrent access, the reset function
wasn't concurrency-safe (and can't easily be made to).
Fix this by stopping the audio callback before doing a reset. After
that, we can do anything without needing synchronization. The callback
is resumed when resuming playback at a later point.
Don't call driver->pause, and make driver->resume and driver->reset
start/stop the audio callback. In the initial state, the audio callback
must be disabled.
JackAudio of course is different. Maybe there is no way to suspend the
audio callback without "disconnecting" it (what jack_deactivate() would
do), so I'm not trying my luck, and implemented a really bad hack doing
active waiting until we get the audio callback into a state where it
won't interfere. Once the callback goes from AO_STATE_WAIT to NONE, we
can be sure that the callback doesn't access the ringbuffer or anything
else anymore. Since both sched_yield() and pthread_yield() apparently
are not always available, use mp_sleep_us(1) to avoid burning CPU during
active waiting.
The ao_jack.c change also removes a race condition: apparently we didn't
initialize _all_ ao fields before starting the audio callback.
In ao_wasapi.c, I'm not sure whether reset really waits for the audio
callback to return. Kovensky says it's not guaranteed, so disable the
reset callback - for now the behavior of ao_wasapi.c is like with
ao_jack.c, and active waiting is used to deal with the audio callback.
2014-05-29 00:24:17 +00:00
|
|
|
* Optional:
|
|
|
|
* control
|
|
|
|
* drain
|
2014-03-08 23:04:37 +00:00
|
|
|
* b) ->play must be NULL. The driver can start the audio API in init(). The
|
|
|
|
* audio API in turn will start a thread and call a callback provided by the
|
|
|
|
* driver. That callback calls ao_read_data() to get audio data. Most
|
|
|
|
* functions are optional and will be emulated if missing (e.g. pausing
|
|
|
|
* is emulated as silence). ->get_delay and ->get_space are never called.
|
|
|
|
* Mandatory:
|
|
|
|
* init
|
|
|
|
* uninit
|
audio/out/pull: remove race conditions
There were subtle and minor race conditions in the pull.c code, and AOs
using it (jack, portaudio, sdl, wasapi). Attempt to remove these.
There was at least a race condition in the ao_reset() implementation:
mp_ring_reset() was called concurrently to the audio callback. While the
ringbuffer uses atomics to allow concurrent access, the reset function
wasn't concurrency-safe (and can't easily be made to).
Fix this by stopping the audio callback before doing a reset. After
that, we can do anything without needing synchronization. The callback
is resumed when resuming playback at a later point.
Don't call driver->pause, and make driver->resume and driver->reset
start/stop the audio callback. In the initial state, the audio callback
must be disabled.
JackAudio of course is different. Maybe there is no way to suspend the
audio callback without "disconnecting" it (what jack_deactivate() would
do), so I'm not trying my luck, and implemented a really bad hack doing
active waiting until we get the audio callback into a state where it
won't interfere. Once the callback goes from AO_STATE_WAIT to NONE, we
can be sure that the callback doesn't access the ringbuffer or anything
else anymore. Since both sched_yield() and pthread_yield() apparently
are not always available, use mp_sleep_us(1) to avoid burning CPU during
active waiting.
The ao_jack.c change also removes a race condition: apparently we didn't
initialize _all_ ao fields before starting the audio callback.
In ao_wasapi.c, I'm not sure whether reset really waits for the audio
callback to return. Kovensky says it's not guaranteed, so disable the
reset callback - for now the behavior of ao_wasapi.c is like with
ao_jack.c, and active waiting is used to deal with the audio callback.
2014-05-29 00:24:17 +00:00
|
|
|
* resume (starts the audio callback)
|
|
|
|
* Also, the following optional callbacks can be provided:
|
|
|
|
* reset (stops the audio callback, resume() restarts it)
|
|
|
|
* control
|
2014-03-08 23:04:37 +00:00
|
|
|
*/
|
2014-03-07 14:24:32 +00:00
|
|
|
struct ao_driver {
|
|
|
|
// If true, use with encoding only.
|
|
|
|
bool encode;
|
|
|
|
// Name used for --ao.
|
|
|
|
const char *name;
|
|
|
|
// Description shown with --ao=help.
|
|
|
|
const char *description;
|
|
|
|
// Init the device using ao->format/ao->channels/ao->samplerate. If the
|
|
|
|
// device doesn't accept these parameters, you can attempt to negotiate
|
|
|
|
// fallback parameters, and set the ao format fields accordingly.
|
|
|
|
int (*init)(struct ao *ao);
|
2014-03-08 23:04:37 +00:00
|
|
|
// Optional. See ao_control() etc. in ao.c
|
2014-03-07 14:24:32 +00:00
|
|
|
int (*control)(struct ao *ao, enum aocontrol cmd, void *arg);
|
2014-03-08 23:49:39 +00:00
|
|
|
void (*uninit)(struct ao *ao);
|
2014-03-07 14:24:32 +00:00
|
|
|
void (*reset)(struct ao*ao);
|
|
|
|
int (*get_space)(struct ao *ao);
|
|
|
|
int (*play)(struct ao *ao, void **data, int samples, int flags);
|
|
|
|
float (*get_delay)(struct ao *ao);
|
|
|
|
void (*pause)(struct ao *ao);
|
|
|
|
void (*resume)(struct ao *ao);
|
2014-03-08 23:49:39 +00:00
|
|
|
void (*drain)(struct ao *ao);
|
2014-03-07 14:24:32 +00:00
|
|
|
|
|
|
|
// For option parsing (see vo.h)
|
|
|
|
int priv_size;
|
|
|
|
const void *priv_defaults;
|
|
|
|
const struct m_option *options;
|
|
|
|
};
|
|
|
|
|
2014-03-08 23:04:37 +00:00
|
|
|
// These functions can be called by AOs.
|
|
|
|
|
2014-03-07 14:24:32 +00:00
|
|
|
int ao_play_silence(struct ao *ao, int samples);
|
2014-04-15 20:38:16 +00:00
|
|
|
void ao_need_data(struct ao *ao);
|
2014-03-08 23:04:37 +00:00
|
|
|
void ao_wait_drain(struct ao *ao);
|
|
|
|
int ao_read_data(struct ao *ao, void **data, int samples, int64_t out_time_us);
|
|
|
|
|
2014-03-07 14:24:32 +00:00
|
|
|
bool ao_chmap_sel_adjust(struct ao *ao, const struct mp_chmap_sel *s,
|
|
|
|
struct mp_chmap *map);
|
|
|
|
bool ao_chmap_sel_get_def(struct ao *ao, const struct mp_chmap_sel *s,
|
|
|
|
struct mp_chmap *map, int num);
|
|
|
|
|
|
|
|
#endif
|