2014-03-08 23:04:37 +00:00
|
|
|
/*
|
|
|
|
* This file is part of mpv.
|
|
|
|
*
|
|
|
|
* mpv 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.
|
|
|
|
*
|
|
|
|
* mpv 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 mpv. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stddef.h>
|
|
|
|
#include <pthread.h>
|
|
|
|
#include <inttypes.h>
|
2014-05-29 21:57:11 +00:00
|
|
|
#include <unistd.h>
|
|
|
|
#include <errno.h>
|
2014-03-08 23:04:37 +00:00
|
|
|
#include <assert.h>
|
|
|
|
|
2014-05-29 21:57:11 +00:00
|
|
|
#include "osdep/io.h"
|
|
|
|
|
2014-03-08 23:04:37 +00:00
|
|
|
#include "ao.h"
|
|
|
|
#include "internal.h"
|
|
|
|
#include "audio/format.h"
|
|
|
|
|
|
|
|
#include "common/msg.h"
|
|
|
|
#include "common/common.h"
|
|
|
|
|
2014-04-15 20:38:16 +00:00
|
|
|
#include "input/input.h"
|
|
|
|
|
2014-03-08 23:04:37 +00:00
|
|
|
#include "osdep/threads.h"
|
2014-04-17 20:50:49 +00:00
|
|
|
#include "osdep/timer.h"
|
2014-08-29 10:09:04 +00:00
|
|
|
#include "osdep/atomics.h"
|
2014-03-08 23:04:37 +00:00
|
|
|
|
|
|
|
#include "audio/audio.h"
|
|
|
|
#include "audio/audio_buffer.h"
|
|
|
|
|
|
|
|
struct ao_push_state {
|
|
|
|
pthread_t thread;
|
|
|
|
pthread_mutex_t lock;
|
|
|
|
pthread_cond_t wakeup;
|
2014-05-30 00:14:45 +00:00
|
|
|
pthread_cond_t wakeup_drain;
|
2014-03-08 23:04:37 +00:00
|
|
|
|
2014-04-15 20:38:16 +00:00
|
|
|
// --- protected by lock
|
|
|
|
|
2014-03-08 23:04:37 +00:00
|
|
|
struct mp_audio_buffer *buffer;
|
|
|
|
|
|
|
|
bool terminate;
|
2014-05-30 00:14:45 +00:00
|
|
|
bool drain;
|
audio/out/push: redo audio waiting
Improve the logic how the audio thread decides how to wait until the AO
is ready for new data. The previous commit makes some of this easier,
although it turned out that it wasn't required, and we still can handle
AOs with bad get_space implementation (although the new code prints an
error message, and it might fail in obscure situations).
The new code is pretty similar to the old one, and the main thing that
changes is that complicated conditions are tweaked. AO waiting is now
used better (mainly instead of max>0, r>0 is used). Whether to wakeup
is reevaluated every time, instead of somehow doing the wrong thing
and compensating for it with a flag.
This fixes the specific situation when the device buffer is full, and
we don't want to buffer more data. In the old code, this wasn't handled
correctly: the AO went to sleep forever, because it prevented proper
wakeup by the AO driver, and as consequence never asked the core for new
data. Commit 4fa3ffeb was a hack-fix against this, and now that we have
a proper solution, this hack is removed as well.
Also make the refill threshold consistent and always use 1/4 of the
buffer. (The threshold is used for situations when an AO doesn't
support proper waiting or chunked processing.)
This commit will probably cause a bunch of regressions again.
2014-09-06 10:59:04 +00:00
|
|
|
bool wait_on_ao;
|
2014-09-05 20:21:06 +00:00
|
|
|
bool still_playing;
|
2014-05-29 21:56:48 +00:00
|
|
|
bool need_wakeup;
|
|
|
|
bool paused;
|
2014-03-08 23:04:37 +00:00
|
|
|
|
|
|
|
// Whether the current buffer contains the complete audio.
|
|
|
|
bool final_chunk;
|
2014-04-17 20:50:49 +00:00
|
|
|
double expected_end_time;
|
2014-05-29 21:57:11 +00:00
|
|
|
|
|
|
|
int wakeup_pipe[2];
|
2014-03-08 23:04:37 +00:00
|
|
|
};
|
|
|
|
|
2014-05-29 21:56:48 +00:00
|
|
|
// lock must be held
|
2014-04-15 20:38:16 +00:00
|
|
|
static void wakeup_playthread(struct ao *ao)
|
|
|
|
{
|
|
|
|
struct ao_push_state *p = ao->api_priv;
|
2014-05-29 21:56:48 +00:00
|
|
|
if (ao->driver->wakeup)
|
|
|
|
ao->driver->wakeup(ao);
|
2014-04-15 20:38:16 +00:00
|
|
|
p->need_wakeup = true;
|
|
|
|
pthread_cond_signal(&p->wakeup);
|
|
|
|
}
|
|
|
|
|
2014-03-08 23:04:37 +00:00
|
|
|
static int control(struct ao *ao, enum aocontrol cmd, void *arg)
|
|
|
|
{
|
|
|
|
int r = CONTROL_UNKNOWN;
|
|
|
|
if (ao->driver->control) {
|
|
|
|
struct ao_push_state *p = ao->api_priv;
|
|
|
|
pthread_mutex_lock(&p->lock);
|
|
|
|
r = ao->driver->control(ao, cmd, arg);
|
|
|
|
pthread_mutex_unlock(&p->lock);
|
|
|
|
}
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2014-09-05 20:21:06 +00:00
|
|
|
static double unlocked_get_delay(struct ao *ao)
|
2014-03-08 23:04:37 +00:00
|
|
|
{
|
|
|
|
struct ao_push_state *p = ao->api_priv;
|
|
|
|
double driver_delay = 0;
|
|
|
|
if (ao->driver->get_delay)
|
|
|
|
driver_delay = ao->driver->get_delay(ao);
|
|
|
|
double delay = driver_delay + mp_audio_buffer_seconds(p->buffer);
|
2014-04-17 20:50:49 +00:00
|
|
|
if (delay >= AO_EOF_DELAY && p->expected_end_time) {
|
|
|
|
if (mp_time_sec() > p->expected_end_time) {
|
|
|
|
MP_ERR(ao, "Audio device EOF reporting is broken!\n");
|
|
|
|
MP_ERR(ao, "Please report this problem.\n");
|
|
|
|
delay = 0;
|
|
|
|
}
|
|
|
|
}
|
2014-03-08 23:04:37 +00:00
|
|
|
return delay;
|
|
|
|
}
|
|
|
|
|
2014-09-05 20:21:06 +00:00
|
|
|
static float get_delay(struct ao *ao)
|
|
|
|
{
|
|
|
|
struct ao_push_state *p = ao->api_priv;
|
|
|
|
pthread_mutex_lock(&p->lock);
|
|
|
|
float delay = unlocked_get_delay(ao);
|
|
|
|
pthread_mutex_unlock(&p->lock);
|
|
|
|
return delay;
|
|
|
|
}
|
|
|
|
|
2014-03-08 23:04:37 +00:00
|
|
|
static void reset(struct ao *ao)
|
|
|
|
{
|
|
|
|
struct ao_push_state *p = ao->api_priv;
|
|
|
|
pthread_mutex_lock(&p->lock);
|
|
|
|
if (ao->driver->reset)
|
|
|
|
ao->driver->reset(ao);
|
|
|
|
mp_audio_buffer_clear(p->buffer);
|
2014-05-29 21:56:48 +00:00
|
|
|
p->paused = false;
|
2014-09-06 14:25:27 +00:00
|
|
|
if (p->still_playing)
|
|
|
|
wakeup_playthread(ao);
|
2014-09-05 20:21:06 +00:00
|
|
|
p->still_playing = false;
|
2014-03-08 23:04:37 +00:00
|
|
|
pthread_mutex_unlock(&p->lock);
|
|
|
|
}
|
|
|
|
|
2014-05-29 21:57:11 +00:00
|
|
|
static void audio_pause(struct ao *ao)
|
2014-03-08 23:04:37 +00:00
|
|
|
{
|
|
|
|
struct ao_push_state *p = ao->api_priv;
|
|
|
|
pthread_mutex_lock(&p->lock);
|
|
|
|
if (ao->driver->pause)
|
|
|
|
ao->driver->pause(ao);
|
2014-05-29 21:56:48 +00:00
|
|
|
p->paused = true;
|
2014-04-15 20:38:16 +00:00
|
|
|
wakeup_playthread(ao);
|
2014-03-08 23:04:37 +00:00
|
|
|
pthread_mutex_unlock(&p->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void resume(struct ao *ao)
|
|
|
|
{
|
|
|
|
struct ao_push_state *p = ao->api_priv;
|
|
|
|
pthread_mutex_lock(&p->lock);
|
|
|
|
if (ao->driver->resume)
|
|
|
|
ao->driver->resume(ao);
|
2014-05-29 21:56:48 +00:00
|
|
|
p->paused = false;
|
2014-04-17 20:50:49 +00:00
|
|
|
p->expected_end_time = 0;
|
2014-04-15 20:38:16 +00:00
|
|
|
wakeup_playthread(ao);
|
2014-03-08 23:04:37 +00:00
|
|
|
pthread_mutex_unlock(&p->lock);
|
|
|
|
}
|
|
|
|
|
2014-03-08 23:49:39 +00:00
|
|
|
static void drain(struct ao *ao)
|
|
|
|
{
|
2014-05-30 00:14:45 +00:00
|
|
|
struct ao_push_state *p = ao->api_priv;
|
|
|
|
|
|
|
|
pthread_mutex_lock(&p->lock);
|
2014-07-13 18:06:33 +00:00
|
|
|
if (p->paused) {
|
|
|
|
pthread_mutex_unlock(&p->lock);
|
|
|
|
return;
|
|
|
|
}
|
2014-05-30 00:14:45 +00:00
|
|
|
p->final_chunk = true;
|
|
|
|
p->drain = true;
|
|
|
|
wakeup_playthread(ao);
|
|
|
|
while (p->drain)
|
|
|
|
pthread_cond_wait(&p->wakeup_drain, &p->lock);
|
|
|
|
pthread_mutex_unlock(&p->lock);
|
|
|
|
|
|
|
|
if (!ao->driver->drain)
|
2014-07-13 18:06:33 +00:00
|
|
|
mp_sleep_us(get_delay(ao) * 1000000);
|
|
|
|
reset(ao);
|
2014-03-08 23:49:39 +00:00
|
|
|
}
|
2014-03-08 23:04:37 +00:00
|
|
|
|
2014-05-11 18:51:49 +00:00
|
|
|
static int unlocked_get_space(struct ao *ao)
|
2014-03-08 23:04:37 +00:00
|
|
|
{
|
|
|
|
struct ao_push_state *p = ao->api_priv;
|
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
|
|
|
int space = mp_audio_buffer_get_write_available(p->buffer);
|
|
|
|
if (ao->driver->get_space) {
|
|
|
|
// The following code attempts to keep the total buffered audio to
|
audio/out/push: redo audio waiting
Improve the logic how the audio thread decides how to wait until the AO
is ready for new data. The previous commit makes some of this easier,
although it turned out that it wasn't required, and we still can handle
AOs with bad get_space implementation (although the new code prints an
error message, and it might fail in obscure situations).
The new code is pretty similar to the old one, and the main thing that
changes is that complicated conditions are tweaked. AO waiting is now
used better (mainly instead of max>0, r>0 is used). Whether to wakeup
is reevaluated every time, instead of somehow doing the wrong thing
and compensating for it with a flag.
This fixes the specific situation when the device buffer is full, and
we don't want to buffer more data. In the old code, this wasn't handled
correctly: the AO went to sleep forever, because it prevented proper
wakeup by the AO driver, and as consequence never asked the core for new
data. Commit 4fa3ffeb was a hack-fix against this, and now that we have
a proper solution, this hack is removed as well.
Also make the refill threshold consistent and always use 1/4 of the
buffer. (The threshold is used for situations when an AO doesn't
support proper waiting or chunked processing.)
This commit will probably cause a bunch of regressions again.
2014-09-06 10:59:04 +00:00
|
|
|
// ao->buffer in order to improve latency.
|
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
|
|
|
int device_space = ao->driver->get_space(ao);
|
|
|
|
int device_buffered = ao->device_buffer - device_space;
|
|
|
|
int soft_buffered = mp_audio_buffer_samples(p->buffer);
|
audio/out/push: redo audio waiting
Improve the logic how the audio thread decides how to wait until the AO
is ready for new data. The previous commit makes some of this easier,
although it turned out that it wasn't required, and we still can handle
AOs with bad get_space implementation (although the new code prints an
error message, and it might fail in obscure situations).
The new code is pretty similar to the old one, and the main thing that
changes is that complicated conditions are tweaked. AO waiting is now
used better (mainly instead of max>0, r>0 is used). Whether to wakeup
is reevaluated every time, instead of somehow doing the wrong thing
and compensating for it with a flag.
This fixes the specific situation when the device buffer is full, and
we don't want to buffer more data. In the old code, this wasn't handled
correctly: the AO went to sleep forever, because it prevented proper
wakeup by the AO driver, and as consequence never asked the core for new
data. Commit 4fa3ffeb was a hack-fix against this, and now that we have
a proper solution, this hack is removed as well.
Also make the refill threshold consistent and always use 1/4 of the
buffer. (The threshold is used for situations when an AO doesn't
support proper waiting or chunked processing.)
This commit will probably cause a bunch of regressions again.
2014-09-06 10:59:04 +00:00
|
|
|
// The extra margin helps avoiding too many wakeups if the AO is fully
|
|
|
|
// byte based and doesn't do proper chunked processing.
|
|
|
|
int min_buffer = ao->buffer + 64;
|
|
|
|
int missing = min_buffer - device_buffered - soft_buffered;
|
|
|
|
// But always keep the device's buffer filled as much as we can.
|
|
|
|
int device_missing = device_space - soft_buffered;
|
|
|
|
missing = MPMAX(missing, device_missing);
|
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
|
|
|
space = MPMIN(space, missing);
|
|
|
|
space = MPMAX(0, space);
|
|
|
|
}
|
2014-05-11 18:51:49 +00:00
|
|
|
return space;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int get_space(struct ao *ao)
|
|
|
|
{
|
|
|
|
struct ao_push_state *p = ao->api_priv;
|
|
|
|
pthread_mutex_lock(&p->lock);
|
|
|
|
int space = unlocked_get_space(ao);
|
2014-03-08 23:04:37 +00:00
|
|
|
pthread_mutex_unlock(&p->lock);
|
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
|
|
|
return space;
|
2014-03-08 23:04:37 +00:00
|
|
|
}
|
|
|
|
|
2014-09-05 20:21:06 +00:00
|
|
|
static bool get_eof(struct ao *ao)
|
|
|
|
{
|
|
|
|
struct ao_push_state *p = ao->api_priv;
|
|
|
|
pthread_mutex_lock(&p->lock);
|
|
|
|
bool eof = !p->still_playing;
|
|
|
|
pthread_mutex_unlock(&p->lock);
|
|
|
|
return eof;
|
|
|
|
}
|
|
|
|
|
2014-03-08 23:04:37 +00:00
|
|
|
static int play(struct ao *ao, void **data, int samples, int flags)
|
|
|
|
{
|
|
|
|
struct ao_push_state *p = ao->api_priv;
|
|
|
|
|
|
|
|
pthread_mutex_lock(&p->lock);
|
|
|
|
|
|
|
|
int write_samples = mp_audio_buffer_get_write_available(p->buffer);
|
|
|
|
write_samples = MPMIN(write_samples, samples);
|
|
|
|
|
audio/out/push: redo audio waiting
Improve the logic how the audio thread decides how to wait until the AO
is ready for new data. The previous commit makes some of this easier,
although it turned out that it wasn't required, and we still can handle
AOs with bad get_space implementation (although the new code prints an
error message, and it might fail in obscure situations).
The new code is pretty similar to the old one, and the main thing that
changes is that complicated conditions are tweaked. AO waiting is now
used better (mainly instead of max>0, r>0 is used). Whether to wakeup
is reevaluated every time, instead of somehow doing the wrong thing
and compensating for it with a flag.
This fixes the specific situation when the device buffer is full, and
we don't want to buffer more data. In the old code, this wasn't handled
correctly: the AO went to sleep forever, because it prevented proper
wakeup by the AO driver, and as consequence never asked the core for new
data. Commit 4fa3ffeb was a hack-fix against this, and now that we have
a proper solution, this hack is removed as well.
Also make the refill threshold consistent and always use 1/4 of the
buffer. (The threshold is used for situations when an AO doesn't
support proper waiting or chunked processing.)
This commit will probably cause a bunch of regressions again.
2014-09-06 10:59:04 +00:00
|
|
|
MP_TRACE(ao, "samples=%d flags=%d r=%d\n", samples, flags, write_samples);
|
|
|
|
|
2014-05-29 21:56:48 +00:00
|
|
|
if (write_samples < samples)
|
|
|
|
flags = flags & ~AOPLAY_FINAL_CHUNK;
|
|
|
|
bool is_final = flags & AOPLAY_FINAL_CHUNK;
|
|
|
|
|
2014-03-08 23:04:37 +00:00
|
|
|
struct mp_audio audio;
|
|
|
|
mp_audio_buffer_get_format(p->buffer, &audio);
|
|
|
|
for (int n = 0; n < ao->num_planes; n++)
|
|
|
|
audio.planes[n] = data[n];
|
|
|
|
audio.samples = write_samples;
|
|
|
|
mp_audio_buffer_append(p->buffer, &audio);
|
|
|
|
|
2014-05-29 21:56:48 +00:00
|
|
|
bool got_data = write_samples > 0 || p->paused || p->final_chunk != is_final;
|
2014-03-08 23:04:37 +00:00
|
|
|
|
2014-05-29 21:56:48 +00:00
|
|
|
p->expected_end_time = 0;
|
|
|
|
p->final_chunk = is_final;
|
|
|
|
p->paused = false;
|
2014-09-05 20:21:06 +00:00
|
|
|
p->still_playing |= write_samples > 0;
|
2014-05-29 21:56:48 +00:00
|
|
|
|
|
|
|
// If we don't have new data, the decoder thread basically promises it
|
|
|
|
// will send new data as soon as it's available.
|
audio/out/push: redo audio waiting
Improve the logic how the audio thread decides how to wait until the AO
is ready for new data. The previous commit makes some of this easier,
although it turned out that it wasn't required, and we still can handle
AOs with bad get_space implementation (although the new code prints an
error message, and it might fail in obscure situations).
The new code is pretty similar to the old one, and the main thing that
changes is that complicated conditions are tweaked. AO waiting is now
used better (mainly instead of max>0, r>0 is used). Whether to wakeup
is reevaluated every time, instead of somehow doing the wrong thing
and compensating for it with a flag.
This fixes the specific situation when the device buffer is full, and
we don't want to buffer more data. In the old code, this wasn't handled
correctly: the AO went to sleep forever, because it prevented proper
wakeup by the AO driver, and as consequence never asked the core for new
data. Commit 4fa3ffeb was a hack-fix against this, and now that we have
a proper solution, this hack is removed as well.
Also make the refill threshold consistent and always use 1/4 of the
buffer. (The threshold is used for situations when an AO doesn't
support proper waiting or chunked processing.)
This commit will probably cause a bunch of regressions again.
2014-09-06 10:59:04 +00:00
|
|
|
if (got_data)
|
2014-05-29 21:56:48 +00:00
|
|
|
wakeup_playthread(ao);
|
2014-03-08 23:04:37 +00:00
|
|
|
pthread_mutex_unlock(&p->lock);
|
|
|
|
return write_samples;
|
|
|
|
}
|
|
|
|
|
|
|
|
// called locked
|
2014-05-29 21:56:48 +00:00
|
|
|
static void ao_play_data(struct ao *ao)
|
2014-03-08 23:04:37 +00:00
|
|
|
{
|
|
|
|
struct ao_push_state *p = ao->api_priv;
|
|
|
|
struct mp_audio data;
|
|
|
|
mp_audio_buffer_peek(p->buffer, &data);
|
|
|
|
int max = data.samples;
|
2014-05-29 21:56:48 +00:00
|
|
|
int space = ao->driver->get_space(ao);
|
|
|
|
space = MPMAX(space, 0);
|
2014-03-08 23:04:37 +00:00
|
|
|
if (data.samples > space)
|
|
|
|
data.samples = space;
|
|
|
|
int flags = 0;
|
|
|
|
if (p->final_chunk && data.samples == max)
|
|
|
|
flags |= AOPLAY_FINAL_CHUNK;
|
2014-05-29 21:56:48 +00:00
|
|
|
MP_STATS(ao, "start ao fill");
|
|
|
|
int r = 0;
|
|
|
|
if (data.samples)
|
|
|
|
r = ao->driver->play(ao, data.planes, data.samples, flags);
|
|
|
|
MP_STATS(ao, "end ao fill");
|
2014-03-08 23:04:37 +00:00
|
|
|
if (r > data.samples) {
|
2014-05-11 14:26:23 +00:00
|
|
|
MP_WARN(ao, "Audio device returned non-sense value.\n");
|
2014-03-08 23:04:37 +00:00
|
|
|
r = data.samples;
|
|
|
|
}
|
2014-05-30 00:14:38 +00:00
|
|
|
r = MPMAX(r, 0);
|
|
|
|
// Probably can't copy the rest of the buffer due to period alignment.
|
audio/out/push: redo audio waiting
Improve the logic how the audio thread decides how to wait until the AO
is ready for new data. The previous commit makes some of this easier,
although it turned out that it wasn't required, and we still can handle
AOs with bad get_space implementation (although the new code prints an
error message, and it might fail in obscure situations).
The new code is pretty similar to the old one, and the main thing that
changes is that complicated conditions are tweaked. AO waiting is now
used better (mainly instead of max>0, r>0 is used). Whether to wakeup
is reevaluated every time, instead of somehow doing the wrong thing
and compensating for it with a flag.
This fixes the specific situation when the device buffer is full, and
we don't want to buffer more data. In the old code, this wasn't handled
correctly: the AO went to sleep forever, because it prevented proper
wakeup by the AO driver, and as consequence never asked the core for new
data. Commit 4fa3ffeb was a hack-fix against this, and now that we have
a proper solution, this hack is removed as well.
Also make the refill threshold consistent and always use 1/4 of the
buffer. (The threshold is used for situations when an AO doesn't
support proper waiting or chunked processing.)
This commit will probably cause a bunch of regressions again.
2014-09-06 10:59:04 +00:00
|
|
|
bool stuck_eof = r <= 0 && space >= max && data.samples > 0;
|
|
|
|
if ((flags & AOPLAY_FINAL_CHUNK) && stuck_eof) {
|
2014-05-30 00:14:38 +00:00
|
|
|
MP_ERR(ao, "Audio output driver seems to ignore AOPLAY_FINAL_CHUNK.\n");
|
|
|
|
r = max;
|
|
|
|
}
|
|
|
|
mp_audio_buffer_skip(p->buffer, r);
|
2014-04-17 20:50:49 +00:00
|
|
|
if (p->final_chunk && mp_audio_buffer_samples(p->buffer) == 0) {
|
|
|
|
p->expected_end_time = mp_time_sec() + AO_EOF_DELAY + 0.25; // + margin
|
|
|
|
if (ao->driver->get_delay)
|
|
|
|
p->expected_end_time += ao->driver->get_delay(ao);
|
|
|
|
}
|
audio/out/push: redo audio waiting
Improve the logic how the audio thread decides how to wait until the AO
is ready for new data. The previous commit makes some of this easier,
although it turned out that it wasn't required, and we still can handle
AOs with bad get_space implementation (although the new code prints an
error message, and it might fail in obscure situations).
The new code is pretty similar to the old one, and the main thing that
changes is that complicated conditions are tweaked. AO waiting is now
used better (mainly instead of max>0, r>0 is used). Whether to wakeup
is reevaluated every time, instead of somehow doing the wrong thing
and compensating for it with a flag.
This fixes the specific situation when the device buffer is full, and
we don't want to buffer more data. In the old code, this wasn't handled
correctly: the AO went to sleep forever, because it prevented proper
wakeup by the AO driver, and as consequence never asked the core for new
data. Commit 4fa3ffeb was a hack-fix against this, and now that we have
a proper solution, this hack is removed as well.
Also make the refill threshold consistent and always use 1/4 of the
buffer. (The threshold is used for situations when an AO doesn't
support proper waiting or chunked processing.)
This commit will probably cause a bunch of regressions again.
2014-09-06 10:59:04 +00:00
|
|
|
// Nothing written, but more input data than space - this must mean the
|
|
|
|
// AO's get_space() doesn't do period alignment correctly.
|
|
|
|
bool stuck = r == 0 && max >= space && space > 0;
|
|
|
|
if (stuck)
|
|
|
|
MP_ERR(ao, "Audio output is reporting incorrect buffer status.\n");
|
|
|
|
// Wait until space becomes available. Also wait if we actually wrote data,
|
|
|
|
// so the AO wakes us up properly if it needs more data.
|
|
|
|
p->wait_on_ao = space == 0 || r > 0 || stuck;
|
2014-09-05 20:21:06 +00:00
|
|
|
p->still_playing |= r > 0;
|
audio/out/push: redo audio waiting
Improve the logic how the audio thread decides how to wait until the AO
is ready for new data. The previous commit makes some of this easier,
although it turned out that it wasn't required, and we still can handle
AOs with bad get_space implementation (although the new code prints an
error message, and it might fail in obscure situations).
The new code is pretty similar to the old one, and the main thing that
changes is that complicated conditions are tweaked. AO waiting is now
used better (mainly instead of max>0, r>0 is used). Whether to wakeup
is reevaluated every time, instead of somehow doing the wrong thing
and compensating for it with a flag.
This fixes the specific situation when the device buffer is full, and
we don't want to buffer more data. In the old code, this wasn't handled
correctly: the AO went to sleep forever, because it prevented proper
wakeup by the AO driver, and as consequence never asked the core for new
data. Commit 4fa3ffeb was a hack-fix against this, and now that we have
a proper solution, this hack is removed as well.
Also make the refill threshold consistent and always use 1/4 of the
buffer. (The threshold is used for situations when an AO doesn't
support proper waiting or chunked processing.)
This commit will probably cause a bunch of regressions again.
2014-09-06 10:59:04 +00:00
|
|
|
// If we just filled the AO completely (r == space), don't refill for a
|
|
|
|
// while. Prevents wakeup feedback with byte-granular AOs.
|
|
|
|
int needed = unlocked_get_space(ao);
|
|
|
|
bool more = needed >= (r == space ? ao->device_buffer / 4 : 1) && !stuck;
|
|
|
|
if (more)
|
|
|
|
mp_input_wakeup(ao->input_ctx); // request more data
|
|
|
|
MP_TRACE(ao, "in=%d flags=%d space=%d r=%d wa=%d needed=%d more=%d\n",
|
|
|
|
max, flags, space, r, p->wait_on_ao, needed, more);
|
2014-03-08 23:04:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void *playthread(void *arg)
|
|
|
|
{
|
|
|
|
struct ao *ao = arg;
|
|
|
|
struct ao_push_state *p = ao->api_priv;
|
2014-05-29 21:56:48 +00:00
|
|
|
pthread_mutex_lock(&p->lock);
|
|
|
|
while (!p->terminate) {
|
2014-06-03 13:57:47 +00:00
|
|
|
if (!p->paused)
|
|
|
|
ao_play_data(ao);
|
2014-05-29 21:56:48 +00:00
|
|
|
|
audio/out/push: redo audio waiting
Improve the logic how the audio thread decides how to wait until the AO
is ready for new data. The previous commit makes some of this easier,
although it turned out that it wasn't required, and we still can handle
AOs with bad get_space implementation (although the new code prints an
error message, and it might fail in obscure situations).
The new code is pretty similar to the old one, and the main thing that
changes is that complicated conditions are tweaked. AO waiting is now
used better (mainly instead of max>0, r>0 is used). Whether to wakeup
is reevaluated every time, instead of somehow doing the wrong thing
and compensating for it with a flag.
This fixes the specific situation when the device buffer is full, and
we don't want to buffer more data. In the old code, this wasn't handled
correctly: the AO went to sleep forever, because it prevented proper
wakeup by the AO driver, and as consequence never asked the core for new
data. Commit 4fa3ffeb was a hack-fix against this, and now that we have
a proper solution, this hack is removed as well.
Also make the refill threshold consistent and always use 1/4 of the
buffer. (The threshold is used for situations when an AO doesn't
support proper waiting or chunked processing.)
This commit will probably cause a bunch of regressions again.
2014-09-06 10:59:04 +00:00
|
|
|
if (p->drain && (!p->wait_on_ao || p->paused)) {
|
2014-05-30 00:14:45 +00:00
|
|
|
if (ao->driver->drain)
|
|
|
|
ao->driver->drain(ao);
|
|
|
|
p->drain = false;
|
|
|
|
pthread_cond_signal(&p->wakeup_drain);
|
|
|
|
}
|
|
|
|
|
2014-05-29 21:56:48 +00:00
|
|
|
if (!p->need_wakeup) {
|
|
|
|
MP_STATS(ao, "start audio wait");
|
audio/out/push: redo audio waiting
Improve the logic how the audio thread decides how to wait until the AO
is ready for new data. The previous commit makes some of this easier,
although it turned out that it wasn't required, and we still can handle
AOs with bad get_space implementation (although the new code prints an
error message, and it might fail in obscure situations).
The new code is pretty similar to the old one, and the main thing that
changes is that complicated conditions are tweaked. AO waiting is now
used better (mainly instead of max>0, r>0 is used). Whether to wakeup
is reevaluated every time, instead of somehow doing the wrong thing
and compensating for it with a flag.
This fixes the specific situation when the device buffer is full, and
we don't want to buffer more data. In the old code, this wasn't handled
correctly: the AO went to sleep forever, because it prevented proper
wakeup by the AO driver, and as consequence never asked the core for new
data. Commit 4fa3ffeb was a hack-fix against this, and now that we have
a proper solution, this hack is removed as well.
Also make the refill threshold consistent and always use 1/4 of the
buffer. (The threshold is used for situations when an AO doesn't
support proper waiting or chunked processing.)
This commit will probably cause a bunch of regressions again.
2014-09-06 10:59:04 +00:00
|
|
|
if (!p->wait_on_ao || p->paused) {
|
2014-05-29 21:56:48 +00:00
|
|
|
// Avoid busy waiting, because the audio API will still report
|
|
|
|
// that it needs new data, even if we're not ready yet, or if
|
|
|
|
// get_space() decides that the amount of audio buffered in the
|
|
|
|
// device is enough, and p->buffer can be empty.
|
|
|
|
// The most important part is that the decoder is woken up, so
|
|
|
|
// that the decoder will wake up us in turn.
|
|
|
|
MP_TRACE(ao, "buffer inactive.\n");
|
2014-09-05 20:21:06 +00:00
|
|
|
|
|
|
|
bool was_playing = p->still_playing;
|
|
|
|
double timeout = -1;
|
|
|
|
if (p->still_playing && !p->paused) {
|
|
|
|
timeout = unlocked_get_delay(ao);
|
|
|
|
if (timeout < AO_EOF_DELAY)
|
|
|
|
p->still_playing = false;
|
|
|
|
}
|
|
|
|
|
audio/out/push: redo audio waiting
Improve the logic how the audio thread decides how to wait until the AO
is ready for new data. The previous commit makes some of this easier,
although it turned out that it wasn't required, and we still can handle
AOs with bad get_space implementation (although the new code prints an
error message, and it might fail in obscure situations).
The new code is pretty similar to the old one, and the main thing that
changes is that complicated conditions are tweaked. AO waiting is now
used better (mainly instead of max>0, r>0 is used). Whether to wakeup
is reevaluated every time, instead of somehow doing the wrong thing
and compensating for it with a flag.
This fixes the specific situation when the device buffer is full, and
we don't want to buffer more data. In the old code, this wasn't handled
correctly: the AO went to sleep forever, because it prevented proper
wakeup by the AO driver, and as consequence never asked the core for new
data. Commit 4fa3ffeb was a hack-fix against this, and now that we have
a proper solution, this hack is removed as well.
Also make the refill threshold consistent and always use 1/4 of the
buffer. (The threshold is used for situations when an AO doesn't
support proper waiting or chunked processing.)
This commit will probably cause a bunch of regressions again.
2014-09-06 10:59:04 +00:00
|
|
|
if (was_playing && !p->still_playing)
|
2014-08-31 12:38:47 +00:00
|
|
|
mp_input_wakeup(ao->input_ctx);
|
2014-09-05 20:21:06 +00:00
|
|
|
|
|
|
|
if (p->still_playing && timeout > 0) {
|
|
|
|
mpthread_cond_timedwait_rel(&p->wakeup, &p->lock, timeout);
|
|
|
|
} else {
|
|
|
|
pthread_cond_wait(&p->wakeup, &p->lock);
|
|
|
|
}
|
2014-03-08 23:04:37 +00:00
|
|
|
} else {
|
2014-05-29 21:56:48 +00:00
|
|
|
if (!ao->driver->wait || ao->driver->wait(ao, &p->lock) < 0) {
|
|
|
|
// Fallback to guessing.
|
audio/out/push: redo audio waiting
Improve the logic how the audio thread decides how to wait until the AO
is ready for new data. The previous commit makes some of this easier,
although it turned out that it wasn't required, and we still can handle
AOs with bad get_space implementation (although the new code prints an
error message, and it might fail in obscure situations).
The new code is pretty similar to the old one, and the main thing that
changes is that complicated conditions are tweaked. AO waiting is now
used better (mainly instead of max>0, r>0 is used). Whether to wakeup
is reevaluated every time, instead of somehow doing the wrong thing
and compensating for it with a flag.
This fixes the specific situation when the device buffer is full, and
we don't want to buffer more data. In the old code, this wasn't handled
correctly: the AO went to sleep forever, because it prevented proper
wakeup by the AO driver, and as consequence never asked the core for new
data. Commit 4fa3ffeb was a hack-fix against this, and now that we have
a proper solution, this hack is removed as well.
Also make the refill threshold consistent and always use 1/4 of the
buffer. (The threshold is used for situations when an AO doesn't
support proper waiting or chunked processing.)
This commit will probably cause a bunch of regressions again.
2014-09-06 10:59:04 +00:00
|
|
|
double timeout = 0;
|
|
|
|
if (ao->driver->get_delay)
|
|
|
|
timeout = ao->driver->get_delay(ao);
|
|
|
|
timeout *= 0.25; // wake up if 25% played
|
2014-05-29 21:56:48 +00:00
|
|
|
mpthread_cond_timedwait_rel(&p->wakeup, &p->lock, timeout);
|
|
|
|
}
|
2014-03-08 23:04:37 +00:00
|
|
|
}
|
2014-05-29 21:56:48 +00:00
|
|
|
MP_STATS(ao, "end audio wait");
|
2014-03-08 23:04:37 +00:00
|
|
|
}
|
2014-04-15 20:38:16 +00:00
|
|
|
p->need_wakeup = false;
|
2014-03-08 23:04:37 +00:00
|
|
|
}
|
2014-05-29 21:56:48 +00:00
|
|
|
pthread_mutex_unlock(&p->lock);
|
2014-03-08 23:04:37 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2014-03-08 23:49:39 +00:00
|
|
|
static void uninit(struct ao *ao)
|
2014-03-08 23:04:37 +00:00
|
|
|
{
|
|
|
|
struct ao_push_state *p = ao->api_priv;
|
|
|
|
|
|
|
|
pthread_mutex_lock(&p->lock);
|
|
|
|
p->terminate = true;
|
2014-04-15 20:38:16 +00:00
|
|
|
wakeup_playthread(ao);
|
2014-03-08 23:04:37 +00:00
|
|
|
pthread_mutex_unlock(&p->lock);
|
|
|
|
|
|
|
|
pthread_join(p->thread, NULL);
|
|
|
|
|
2014-03-08 23:49:39 +00:00
|
|
|
ao->driver->uninit(ao);
|
2014-03-08 23:04:37 +00:00
|
|
|
|
2014-05-29 21:57:11 +00:00
|
|
|
for (int n = 0; n < 2; n++)
|
|
|
|
close(p->wakeup_pipe[n]);
|
|
|
|
|
2014-03-08 23:04:37 +00:00
|
|
|
pthread_cond_destroy(&p->wakeup);
|
2014-05-30 00:14:45 +00:00
|
|
|
pthread_cond_destroy(&p->wakeup_drain);
|
2014-03-08 23:04:37 +00:00
|
|
|
pthread_mutex_destroy(&p->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int init(struct ao *ao)
|
|
|
|
{
|
|
|
|
struct ao_push_state *p = ao->api_priv;
|
|
|
|
|
|
|
|
pthread_mutex_init(&p->lock, NULL);
|
|
|
|
pthread_cond_init(&p->wakeup, NULL);
|
2014-05-30 00:14:45 +00:00
|
|
|
pthread_cond_init(&p->wakeup_drain, NULL);
|
2014-07-26 18:26:27 +00:00
|
|
|
mp_make_wakeup_pipe(p->wakeup_pipe);
|
2014-03-08 23:04:37 +00:00
|
|
|
|
|
|
|
p->buffer = mp_audio_buffer_create(ao);
|
|
|
|
mp_audio_buffer_reinit_fmt(p->buffer, ao->format,
|
|
|
|
&ao->channels, ao->samplerate);
|
|
|
|
mp_audio_buffer_preallocate_min(p->buffer, ao->buffer);
|
2014-07-25 12:30:59 +00:00
|
|
|
if (pthread_create(&p->thread, NULL, playthread, ao))
|
|
|
|
goto err;
|
2014-03-08 23:04:37 +00:00
|
|
|
return 0;
|
2014-07-25 12:30:59 +00:00
|
|
|
err:
|
|
|
|
ao->driver->uninit(ao);
|
|
|
|
return -1;
|
2014-03-08 23:04:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
const struct ao_driver ao_api_push = {
|
|
|
|
.init = init,
|
|
|
|
.control = control,
|
|
|
|
.uninit = uninit,
|
|
|
|
.reset = reset,
|
|
|
|
.get_space = get_space,
|
|
|
|
.play = play,
|
|
|
|
.get_delay = get_delay,
|
2014-05-29 21:57:11 +00:00
|
|
|
.pause = audio_pause,
|
2014-03-08 23:04:37 +00:00
|
|
|
.resume = resume,
|
2014-03-08 23:49:39 +00:00
|
|
|
.drain = drain,
|
2014-09-05 20:21:06 +00:00
|
|
|
.get_eof = get_eof,
|
2014-03-08 23:04:37 +00:00
|
|
|
.priv_size = sizeof(struct ao_push_state),
|
|
|
|
};
|
|
|
|
|
2014-04-15 20:38:16 +00:00
|
|
|
// Must be called locked.
|
2014-03-08 23:04:37 +00:00
|
|
|
int ao_play_silence(struct ao *ao, int samples)
|
|
|
|
{
|
|
|
|
assert(ao->api == &ao_api_push);
|
|
|
|
if (samples <= 0 || AF_FORMAT_IS_SPECIAL(ao->format) || !ao->driver->play)
|
|
|
|
return 0;
|
|
|
|
char *p = talloc_size(NULL, samples * ao->sstride);
|
|
|
|
af_fill_silence(p, samples * ao->sstride, ao->format);
|
|
|
|
void *tmp[MP_NUM_CHANNELS];
|
|
|
|
for (int n = 0; n < MP_NUM_CHANNELS; n++)
|
|
|
|
tmp[n] = p;
|
|
|
|
int r = ao->driver->play(ao, tmp, samples, 0);
|
|
|
|
talloc_free(p);
|
|
|
|
return r;
|
|
|
|
}
|
2014-05-29 21:57:11 +00:00
|
|
|
|
|
|
|
#ifndef __MINGW32__
|
|
|
|
|
|
|
|
#include <poll.h>
|
|
|
|
|
|
|
|
#define MAX_POLL_FDS 20
|
|
|
|
|
|
|
|
// Call poll() for the given fds. This will extend the given fds with the
|
|
|
|
// wakeup pipe, so ao_wakeup_poll() will basically interrupt this function.
|
|
|
|
// Unlocks the lock temporarily.
|
2014-05-30 21:54:11 +00:00
|
|
|
// Returns <0 on error, 0 on success, 1 if the caller should return immediately.
|
2014-05-29 21:57:11 +00:00
|
|
|
int ao_wait_poll(struct ao *ao, struct pollfd *fds, int num_fds,
|
|
|
|
pthread_mutex_t *lock)
|
|
|
|
{
|
|
|
|
struct ao_push_state *p = ao->api_priv;
|
|
|
|
assert(ao->api == &ao_api_push);
|
|
|
|
assert(&p->lock == lock);
|
|
|
|
|
|
|
|
if (num_fds > MAX_POLL_FDS || p->wakeup_pipe[0] < 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
struct pollfd p_fds[MAX_POLL_FDS];
|
|
|
|
memcpy(p_fds, fds, num_fds * sizeof(p_fds[0]));
|
|
|
|
p_fds[num_fds] = (struct pollfd){
|
|
|
|
.fd = p->wakeup_pipe[0],
|
|
|
|
.events = POLLIN,
|
|
|
|
};
|
|
|
|
|
|
|
|
pthread_mutex_unlock(&p->lock);
|
|
|
|
int r = poll(p_fds, num_fds + 1, -1);
|
|
|
|
r = r < 0 ? -errno : 0;
|
|
|
|
pthread_mutex_lock(&p->lock);
|
|
|
|
|
|
|
|
memcpy(fds, p_fds, num_fds * sizeof(fds[0]));
|
2014-05-30 21:54:11 +00:00
|
|
|
bool wakeup = false;
|
2014-05-29 21:57:11 +00:00
|
|
|
if (p_fds[num_fds].revents & POLLIN) {
|
2014-05-30 21:54:11 +00:00
|
|
|
wakeup = true;
|
2014-05-29 21:57:11 +00:00
|
|
|
// flush the wakeup pipe contents - might "drown" some wakeups, but
|
|
|
|
// that's ok for our use-case
|
|
|
|
char buf[100];
|
|
|
|
read(p->wakeup_pipe[0], buf, sizeof(buf));
|
|
|
|
}
|
2014-05-30 21:54:11 +00:00
|
|
|
return (r >= 0 || r == -EINTR) ? wakeup : -1;
|
2014-05-29 21:57:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void ao_wakeup_poll(struct ao *ao)
|
|
|
|
{
|
|
|
|
assert(ao->api == &ao_api_push);
|
|
|
|
struct ao_push_state *p = ao->api_priv;
|
|
|
|
|
|
|
|
write(p->wakeup_pipe[1], &(char){0}, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|