2013-10-29 21:38:29 +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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stddef.h>
|
|
|
|
#include <stdbool.h>
|
|
|
|
#include <inttypes.h>
|
2014-07-28 18:40:43 +00:00
|
|
|
#include <limits.h>
|
2013-10-29 21:38:29 +00:00
|
|
|
#include <math.h>
|
|
|
|
#include <assert.h>
|
|
|
|
|
|
|
|
#include "config.h"
|
|
|
|
#include "talloc.h"
|
|
|
|
|
2013-12-17 01:39:45 +00:00
|
|
|
#include "common/msg.h"
|
2014-03-07 14:23:03 +00:00
|
|
|
#include "common/encode.h"
|
2013-12-17 01:02:25 +00:00
|
|
|
#include "options/options.h"
|
2013-12-17 01:39:45 +00:00
|
|
|
#include "common/common.h"
|
2013-10-29 21:38:29 +00:00
|
|
|
|
|
|
|
#include "audio/mixer.h"
|
2013-11-10 22:38:18 +00:00
|
|
|
#include "audio/audio.h"
|
|
|
|
#include "audio/audio_buffer.h"
|
2013-10-29 21:38:29 +00:00
|
|
|
#include "audio/decode/dec_audio.h"
|
|
|
|
#include "audio/filter/af.h"
|
|
|
|
#include "audio/out/ao.h"
|
|
|
|
#include "demux/demux.h"
|
2013-11-23 20:36:20 +00:00
|
|
|
#include "video/decode/dec_video.h"
|
2013-10-29 21:38:29 +00:00
|
|
|
|
2013-12-17 00:08:53 +00:00
|
|
|
#include "core.h"
|
2014-02-17 01:52:26 +00:00
|
|
|
#include "command.h"
|
2013-10-29 21:38:29 +00:00
|
|
|
|
2014-11-10 19:16:25 +00:00
|
|
|
static int try_filter(struct MPContext *mpctx,
|
|
|
|
char *name, char *label, char **args)
|
|
|
|
{
|
|
|
|
struct dec_audio *d_audio = mpctx->d_audio;
|
|
|
|
|
|
|
|
if (af_find_by_label(d_audio->afilter, label))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
struct af_instance *af = af_add(d_audio->afilter, name, args);
|
|
|
|
if (!af)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
af->label = talloc_strdup(af, label);
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2014-07-24 13:27:40 +00:00
|
|
|
static int recreate_audio_filters(struct MPContext *mpctx)
|
2013-10-29 21:38:29 +00:00
|
|
|
{
|
2014-10-01 23:47:27 +00:00
|
|
|
assert(mpctx->d_audio);
|
audio: use the decoder buffer's format, not sh_audio
When the decoder detects a format change, it overwrites the values
stored in sh_audio (this affects the members sample_format, samplerate,
channels). In the case when the old audio data still needs to be
played/filtered, the audio format as identified by sh_audio and the
format used for the decoder buffer can mismatch. In particular, they
will mismatch in the very unlikely but possible case the audio chain is
reinitialized while old data is draining during a format change.
Or in other words, sh_audio might contain the new format, while the
audio chain is still configured to use the old format.
Currently, the audio code (player/audio.c and init_audio_filters) access
sh_audio to get the current format. This is in theory incorrect for the
reasons mentioned above. Use the decoder buffer's format instead, which
should be correct at any point.
2013-11-18 12:57:17 +00:00
|
|
|
|
2014-10-01 23:47:27 +00:00
|
|
|
struct MPOpts *opts = mpctx->opts;
|
2014-11-10 19:16:25 +00:00
|
|
|
struct af_stream *afs = mpctx->d_audio->afilter;
|
audio: use the decoder buffer's format, not sh_audio
When the decoder detects a format change, it overwrites the values
stored in sh_audio (this affects the members sample_format, samplerate,
channels). In the case when the old audio data still needs to be
played/filtered, the audio format as identified by sh_audio and the
format used for the decoder buffer can mismatch. In particular, they
will mismatch in the very unlikely but possible case the audio chain is
reinitialized while old data is draining during a format change.
Or in other words, sh_audio might contain the new format, while the
audio chain is still configured to use the old format.
Currently, the audio code (player/audio.c and init_audio_filters) access
sh_audio to get the current format. This is in theory incorrect for the
reasons mentioned above. Use the decoder buffer's format instead, which
should be correct at any point.
2013-11-18 12:57:17 +00:00
|
|
|
|
2014-11-10 19:16:25 +00:00
|
|
|
double speed = opts->playback_speed;
|
|
|
|
|
|
|
|
if (speed != 1.0) {
|
|
|
|
int method = AF_CONTROL_SET_PLAYBACK_SPEED_RESAMPLE;
|
2015-02-12 10:58:35 +00:00
|
|
|
if (opts->pitch_correction)
|
2014-11-10 19:16:25 +00:00
|
|
|
method = AF_CONTROL_SET_PLAYBACK_SPEED;
|
|
|
|
if (!af_control_any_rev(afs, method, &speed)) {
|
|
|
|
if (af_remove_by_label(afs, "playback-speed") < 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
// Compatibility: if the user uses --af=scaletempo, always use
|
|
|
|
// this filter to change speed. Don't insert a second "scaletempo"
|
|
|
|
// filter either.
|
|
|
|
if (!af_control_any_rev(afs, AF_CONTROL_SET_PLAYBACK_SPEED, &speed))
|
|
|
|
{
|
|
|
|
char *filter = method == AF_CONTROL_SET_PLAYBACK_SPEED
|
2015-03-02 18:09:44 +00:00
|
|
|
? "scaletempo" : "lavrresample";
|
2014-11-10 19:16:25 +00:00
|
|
|
if (try_filter(mpctx, filter, "playback-speed", NULL) < 0)
|
|
|
|
return -1;
|
|
|
|
// Try again.
|
|
|
|
if (!af_control_any_rev(afs, method, &speed))
|
|
|
|
return -1;
|
2015-02-10 21:45:07 +00:00
|
|
|
} else {
|
|
|
|
method = AF_CONTROL_SET_PLAYBACK_SPEED;
|
2014-11-10 19:16:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (af_remove_by_label(afs, "playback-speed") < 0)
|
|
|
|
return -1;
|
|
|
|
// The filters could be inserted by the user (we don't remove them).
|
|
|
|
af_control_any_rev(afs, AF_CONTROL_SET_PLAYBACK_SPEED, &speed);
|
|
|
|
af_control_any_rev(afs, AF_CONTROL_SET_PLAYBACK_SPEED_RESAMPLE, &speed);
|
2013-10-29 21:38:29 +00:00
|
|
|
}
|
2014-10-01 23:47:27 +00:00
|
|
|
|
2015-03-02 18:09:44 +00:00
|
|
|
if (afs->initialized < 1 && af_init(afs) < 0) {
|
2013-10-29 21:38:29 +00:00
|
|
|
MP_ERR(mpctx, "Couldn't find matching filter/ao format!\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2014-10-01 23:47:27 +00:00
|
|
|
mixer_reinit_audio(mpctx->mixer, mpctx->ao, afs);
|
2013-10-29 21:38:29 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int reinit_audio_filters(struct MPContext *mpctx)
|
|
|
|
{
|
2013-11-23 20:22:17 +00:00
|
|
|
struct dec_audio *d_audio = mpctx->d_audio;
|
|
|
|
if (!d_audio)
|
2014-03-30 17:21:54 +00:00
|
|
|
return 0;
|
2013-10-29 21:38:29 +00:00
|
|
|
|
2013-11-23 20:22:17 +00:00
|
|
|
af_uninit(mpctx->d_audio->afilter);
|
|
|
|
if (af_init(mpctx->d_audio->afilter) < 0)
|
2013-10-29 21:38:29 +00:00
|
|
|
return -1;
|
|
|
|
if (recreate_audio_filters(mpctx) < 0)
|
|
|
|
return -1;
|
|
|
|
|
2014-03-30 17:21:54 +00:00
|
|
|
return 1;
|
2013-10-29 21:38:29 +00:00
|
|
|
}
|
|
|
|
|
2014-10-02 00:49:05 +00:00
|
|
|
void set_playback_speed(struct MPContext *mpctx, double new_speed)
|
|
|
|
{
|
|
|
|
struct MPOpts *opts = mpctx->opts;
|
|
|
|
|
|
|
|
// Adjust time until next frame flip for nosound mode
|
|
|
|
mpctx->time_frame *= opts->playback_speed / new_speed;
|
|
|
|
|
|
|
|
opts->playback_speed = new_speed;
|
|
|
|
|
2014-10-02 00:58:52 +00:00
|
|
|
if (!mpctx->d_audio)
|
|
|
|
return;
|
|
|
|
|
|
|
|
recreate_audio_filters(mpctx);
|
2014-10-02 00:49:05 +00:00
|
|
|
}
|
|
|
|
|
2014-07-30 21:01:55 +00:00
|
|
|
void reset_audio_state(struct MPContext *mpctx)
|
|
|
|
{
|
|
|
|
if (mpctx->d_audio)
|
|
|
|
audio_reset_decoding(mpctx->d_audio);
|
2014-09-04 21:35:11 +00:00
|
|
|
if (mpctx->ao_buffer)
|
|
|
|
mp_audio_buffer_clear(mpctx->ao_buffer);
|
2014-07-30 21:01:55 +00:00
|
|
|
mpctx->audio_status = mpctx->d_audio ? STATUS_SYNCING : STATUS_EOF;
|
2015-01-30 22:49:30 +00:00
|
|
|
mpctx->delay = 0;
|
2014-07-30 21:01:55 +00:00
|
|
|
}
|
|
|
|
|
2014-10-03 17:57:49 +00:00
|
|
|
void uninit_audio_out(struct MPContext *mpctx)
|
|
|
|
{
|
|
|
|
if (mpctx->ao) {
|
|
|
|
// Note: with gapless_audio, stop_play is not correctly set
|
|
|
|
if (mpctx->opts->gapless_audio || mpctx->stop_play == AT_END_OF_FILE)
|
|
|
|
ao_drain(mpctx->ao);
|
2014-11-12 13:15:49 +00:00
|
|
|
mixer_uninit_audio(mpctx->mixer);
|
2014-10-03 17:57:49 +00:00
|
|
|
ao_uninit(mpctx->ao);
|
|
|
|
}
|
|
|
|
mpctx->ao = NULL;
|
|
|
|
talloc_free(mpctx->ao_decoder_fmt);
|
|
|
|
mpctx->ao_decoder_fmt = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
void uninit_audio_chain(struct MPContext *mpctx)
|
|
|
|
{
|
|
|
|
if (mpctx->d_audio) {
|
|
|
|
mixer_uninit_audio(mpctx->mixer);
|
|
|
|
audio_uninit(mpctx->d_audio);
|
|
|
|
mpctx->d_audio = NULL;
|
|
|
|
talloc_free(mpctx->ao_buffer);
|
|
|
|
mpctx->ao_buffer = NULL;
|
|
|
|
mpctx->audio_status = STATUS_EOF;
|
|
|
|
reselect_demux_streams(mpctx);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-10-29 21:38:29 +00:00
|
|
|
void reinit_audio_chain(struct MPContext *mpctx)
|
|
|
|
{
|
|
|
|
struct MPOpts *opts = mpctx->opts;
|
2013-12-24 16:46:08 +00:00
|
|
|
struct track *track = mpctx->current_track[0][STREAM_AUDIO];
|
2014-07-29 15:55:28 +00:00
|
|
|
struct sh_stream *sh = track ? track->stream : NULL;
|
2013-11-23 20:22:17 +00:00
|
|
|
if (!sh) {
|
2014-10-03 17:57:49 +00:00
|
|
|
uninit_audio_out(mpctx);
|
2013-10-29 21:38:29 +00:00
|
|
|
goto no_audio;
|
|
|
|
}
|
|
|
|
|
2014-02-17 01:52:26 +00:00
|
|
|
mp_notify(mpctx, MPV_EVENT_AUDIO_RECONFIG, NULL);
|
|
|
|
|
2014-10-03 17:57:49 +00:00
|
|
|
if (!mpctx->d_audio) {
|
2013-11-23 20:22:17 +00:00
|
|
|
mpctx->d_audio = talloc_zero(NULL, struct dec_audio);
|
2013-12-21 17:23:59 +00:00
|
|
|
mpctx->d_audio->log = mp_log_new(mpctx->d_audio, mpctx->log, "!ad");
|
|
|
|
mpctx->d_audio->global = mpctx->global;
|
2013-11-23 20:22:17 +00:00
|
|
|
mpctx->d_audio->opts = opts;
|
|
|
|
mpctx->d_audio->header = sh;
|
2014-11-10 21:01:23 +00:00
|
|
|
mpctx->d_audio->pool = mp_audio_pool_create(mpctx->d_audio);
|
2014-10-01 23:47:27 +00:00
|
|
|
mpctx->d_audio->afilter = af_new(mpctx->global);
|
|
|
|
mpctx->d_audio->afilter->replaygain_data = sh->audio->replaygain_data;
|
2014-09-04 21:35:11 +00:00
|
|
|
mpctx->ao_buffer = mp_audio_buffer_create(NULL);
|
2013-11-23 20:22:17 +00:00
|
|
|
if (!audio_init_best_codec(mpctx->d_audio, opts->audio_decoders))
|
|
|
|
goto init_error;
|
2014-07-30 21:01:55 +00:00
|
|
|
reset_audio_state(mpctx);
|
2014-09-05 15:48:15 +00:00
|
|
|
|
|
|
|
if (mpctx->ao) {
|
|
|
|
struct mp_audio fmt;
|
|
|
|
ao_get_format(mpctx->ao, &fmt);
|
|
|
|
mp_audio_buffer_reinit(mpctx->ao_buffer, &fmt);
|
|
|
|
}
|
2013-10-29 21:38:29 +00:00
|
|
|
}
|
2013-11-23 20:22:17 +00:00
|
|
|
assert(mpctx->d_audio);
|
2013-10-29 21:38:29 +00:00
|
|
|
|
2014-11-10 21:01:23 +00:00
|
|
|
struct mp_audio in_format = mpctx->d_audio->decode_format;
|
audio: use the decoder buffer's format, not sh_audio
When the decoder detects a format change, it overwrites the values
stored in sh_audio (this affects the members sample_format, samplerate,
channels). In the case when the old audio data still needs to be
played/filtered, the audio format as identified by sh_audio and the
format used for the decoder buffer can mismatch. In particular, they
will mismatch in the very unlikely but possible case the audio chain is
reinitialized while old data is draining during a format change.
Or in other words, sh_audio might contain the new format, while the
audio chain is still configured to use the old format.
Currently, the audio code (player/audio.c and init_audio_filters) access
sh_audio to get the current format. This is in theory incorrect for the
reasons mentioned above. Use the decoder buffer's format instead, which
should be correct at any point.
2013-11-18 12:57:17 +00:00
|
|
|
|
2014-07-28 18:40:43 +00:00
|
|
|
if (!mp_audio_config_valid(&in_format)) {
|
|
|
|
// We don't know the audio format yet - so configure it later as we're
|
|
|
|
// resyncing. fill_audio_buffers() will call this function again.
|
|
|
|
mpctx->sleeptime = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-10-02 00:58:52 +00:00
|
|
|
// Weak gapless audio: drain AO on decoder format changes
|
2014-10-03 17:57:49 +00:00
|
|
|
if (mpctx->ao_decoder_fmt && mpctx->ao && opts->gapless_audio < 0 &&
|
|
|
|
!mp_audio_config_equals(mpctx->ao_decoder_fmt, &in_format))
|
2014-06-08 21:54:05 +00:00
|
|
|
{
|
2014-10-03 17:57:49 +00:00
|
|
|
uninit_audio_out(mpctx);
|
2014-06-08 21:54:05 +00:00
|
|
|
}
|
|
|
|
|
2014-10-01 23:47:27 +00:00
|
|
|
struct af_stream *afs = mpctx->d_audio->afilter;
|
|
|
|
|
2015-01-20 13:33:08 +00:00
|
|
|
afs->output = (struct mp_audio){0};
|
2014-10-03 17:57:49 +00:00
|
|
|
if (mpctx->ao) {
|
2014-10-01 23:47:27 +00:00
|
|
|
ao_get_format(mpctx->ao, &afs->output);
|
2015-01-20 13:33:08 +00:00
|
|
|
} else if (!AF_FORMAT_IS_SPECIAL(in_format.format)) {
|
2014-10-01 23:47:27 +00:00
|
|
|
afs->output.rate = opts->force_srate;
|
|
|
|
mp_audio_set_format(&afs->output, opts->audio_output_format);
|
2015-01-20 13:33:08 +00:00
|
|
|
mp_audio_set_channels(&afs->output, &opts->audio_output_channels);
|
2013-10-29 21:38:29 +00:00
|
|
|
}
|
|
|
|
|
2014-10-01 23:47:27 +00:00
|
|
|
// filter input format: same as codec's output format:
|
2014-11-10 21:01:23 +00:00
|
|
|
afs->input = in_format;
|
2014-10-01 23:47:27 +00:00
|
|
|
|
2014-07-24 13:27:40 +00:00
|
|
|
// Determine what the filter chain outputs. recreate_audio_filters() also
|
2013-10-29 21:38:29 +00:00
|
|
|
// needs this for testing whether playback speed is changed by resampling
|
|
|
|
// or using a special filter.
|
2014-10-01 23:47:27 +00:00
|
|
|
if (af_init(afs) < 0) {
|
2013-10-29 21:38:29 +00:00
|
|
|
MP_ERR(mpctx, "Error at audio filter chain pre-init!\n");
|
|
|
|
goto init_error;
|
|
|
|
}
|
|
|
|
|
2014-10-03 17:57:49 +00:00
|
|
|
if (!mpctx->ao) {
|
2014-10-01 23:47:27 +00:00
|
|
|
afs->initialized = 0; // do it again
|
|
|
|
|
|
|
|
mp_chmap_remove_useless_channels(&afs->output.channels,
|
2013-10-29 21:38:29 +00:00
|
|
|
&opts->audio_output_channels);
|
2014-10-01 23:47:27 +00:00
|
|
|
mp_audio_set_channels(&afs->output, &afs->output.channels);
|
|
|
|
|
2013-10-29 21:38:29 +00:00
|
|
|
mpctx->ao = ao_init_best(mpctx->global, mpctx->input,
|
2014-10-01 23:47:27 +00:00
|
|
|
mpctx->encode_lavc_ctx, afs->output.rate,
|
|
|
|
afs->output.format, afs->output.channels);
|
2013-10-29 21:38:29 +00:00
|
|
|
struct ao *ao = mpctx->ao;
|
|
|
|
if (!ao) {
|
|
|
|
MP_ERR(mpctx, "Could not open/initialize audio device -> no sound.\n");
|
2014-10-28 15:19:07 +00:00
|
|
|
mpctx->error_playing = MPV_ERROR_AO_INIT_FAILED;
|
2013-10-29 21:38:29 +00:00
|
|
|
goto init_error;
|
|
|
|
}
|
2013-11-10 22:38:18 +00:00
|
|
|
|
2014-03-07 14:24:32 +00:00
|
|
|
struct mp_audio fmt;
|
|
|
|
ao_get_format(ao, &fmt);
|
2013-11-10 22:38:18 +00:00
|
|
|
|
2014-03-07 14:24:32 +00:00
|
|
|
mp_audio_buffer_reinit(mpctx->ao_buffer, &fmt);
|
2014-10-01 23:47:27 +00:00
|
|
|
afs->output = fmt;
|
2014-03-07 14:24:32 +00:00
|
|
|
|
2014-06-08 21:54:05 +00:00
|
|
|
mpctx->ao_decoder_fmt = talloc(NULL, struct mp_audio);
|
|
|
|
*mpctx->ao_decoder_fmt = in_format;
|
|
|
|
|
2014-11-25 10:11:31 +00:00
|
|
|
MP_INFO(mpctx, "AO: [%s] %s\n", ao_get_name(ao),
|
|
|
|
mp_audio_config_to_str(&fmt));
|
2014-03-07 14:24:32 +00:00
|
|
|
MP_VERBOSE(mpctx, "AO: Description: %s\n", ao_get_description(ao));
|
2013-11-09 23:49:13 +00:00
|
|
|
update_window_title(mpctx, true);
|
2013-10-29 21:38:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (recreate_audio_filters(mpctx) < 0)
|
|
|
|
goto init_error;
|
|
|
|
|
2014-10-02 00:58:52 +00:00
|
|
|
set_playback_speed(mpctx, opts->playback_speed);
|
|
|
|
|
2013-10-29 21:38:29 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
init_error:
|
2014-10-03 17:57:49 +00:00
|
|
|
uninit_audio_chain(mpctx);
|
|
|
|
uninit_audio_out(mpctx);
|
2013-10-29 21:38:29 +00:00
|
|
|
no_audio:
|
2014-10-02 01:12:45 +00:00
|
|
|
if (track)
|
2014-10-23 16:31:43 +00:00
|
|
|
error_on_track(mpctx, track);
|
2013-10-29 21:38:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Return pts value corresponding to the end point of audio written to the
|
|
|
|
// ao so far.
|
|
|
|
double written_audio_pts(struct MPContext *mpctx)
|
|
|
|
{
|
2013-11-23 20:22:17 +00:00
|
|
|
struct dec_audio *d_audio = mpctx->d_audio;
|
|
|
|
if (!d_audio)
|
2013-10-29 21:38:29 +00:00
|
|
|
return MP_NOPTS_VALUE;
|
|
|
|
|
2014-11-10 21:01:23 +00:00
|
|
|
struct mp_audio in_format = d_audio->decode_format;
|
audio: use the decoder buffer's format, not sh_audio
When the decoder detects a format change, it overwrites the values
stored in sh_audio (this affects the members sample_format, samplerate,
channels). In the case when the old audio data still needs to be
played/filtered, the audio format as identified by sh_audio and the
format used for the decoder buffer can mismatch. In particular, they
will mismatch in the very unlikely but possible case the audio chain is
reinitialized while old data is draining during a format change.
Or in other words, sh_audio might contain the new format, while the
audio chain is still configured to use the old format.
Currently, the audio code (player/audio.c and init_audio_filters) access
sh_audio to get the current format. This is in theory incorrect for the
reasons mentioned above. Use the decoder buffer's format instead, which
should be correct at any point.
2013-11-18 12:57:17 +00:00
|
|
|
|
2014-10-01 23:47:27 +00:00
|
|
|
if (!mp_audio_config_valid(&in_format) || d_audio->afilter->initialized < 1)
|
2014-09-04 21:25:11 +00:00
|
|
|
return MP_NOPTS_VALUE;
|
2014-07-28 18:40:43 +00:00
|
|
|
|
2013-10-29 21:38:29 +00:00
|
|
|
// first calculate the end pts of audio that has been output by decoder
|
2013-11-23 20:22:17 +00:00
|
|
|
double a_pts = d_audio->pts;
|
2013-10-29 21:38:29 +00:00
|
|
|
if (a_pts == MP_NOPTS_VALUE)
|
|
|
|
return MP_NOPTS_VALUE;
|
|
|
|
|
2013-11-23 20:22:17 +00:00
|
|
|
// d_audio->pts is the timestamp of the latest input packet with
|
|
|
|
// known pts that the decoder has decoded. d_audio->pts_bytes is
|
2013-10-29 21:38:29 +00:00
|
|
|
// the amount of bytes the decoder has written after that timestamp.
|
2013-11-23 20:22:17 +00:00
|
|
|
a_pts += d_audio->pts_offset / (double)in_format.rate;
|
2013-10-29 21:38:29 +00:00
|
|
|
|
|
|
|
// Now a_pts hopefully holds the pts for end of audio from decoder.
|
|
|
|
// Subtract data in buffers between decoder and audio out.
|
|
|
|
|
|
|
|
// Decoded but not filtered
|
2014-11-10 21:01:23 +00:00
|
|
|
if (d_audio->waiting)
|
|
|
|
a_pts -= d_audio->waiting->samples / (double)in_format.rate;
|
2013-10-29 21:38:29 +00:00
|
|
|
|
2013-11-10 22:38:18 +00:00
|
|
|
// Data buffered in audio filters, measured in seconds of "missing" output
|
2013-11-23 20:22:17 +00:00
|
|
|
double buffered_output = af_calc_delay(d_audio->afilter);
|
2013-10-29 21:38:29 +00:00
|
|
|
|
|
|
|
// Data that was ready for ao but was buffered because ao didn't fully
|
|
|
|
// accept everything to internal buffers yet
|
2014-03-07 14:24:32 +00:00
|
|
|
buffered_output += mp_audio_buffer_seconds(mpctx->ao_buffer);
|
2013-10-29 21:38:29 +00:00
|
|
|
|
|
|
|
// Filters divide audio length by playback_speed, so multiply by it
|
|
|
|
// to get the length in original units without speedup or slowdown
|
2013-11-10 22:38:18 +00:00
|
|
|
a_pts -= buffered_output * mpctx->opts->playback_speed;
|
2013-10-29 21:38:29 +00:00
|
|
|
|
2014-08-15 21:32:37 +00:00
|
|
|
return a_pts +
|
|
|
|
get_track_video_offset(mpctx, mpctx->current_track[0][STREAM_AUDIO]);
|
2013-10-29 21:38:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Return pts value corresponding to currently playing audio.
|
|
|
|
double playing_audio_pts(struct MPContext *mpctx)
|
|
|
|
{
|
|
|
|
double pts = written_audio_pts(mpctx);
|
2014-07-28 18:40:43 +00:00
|
|
|
if (pts == MP_NOPTS_VALUE || !mpctx->ao)
|
2013-10-29 21:38:29 +00:00
|
|
|
return pts;
|
|
|
|
return pts - mpctx->opts->playback_speed * ao_get_delay(mpctx->ao);
|
|
|
|
}
|
|
|
|
|
2013-11-10 22:38:18 +00:00
|
|
|
static int write_to_ao(struct MPContext *mpctx, struct mp_audio *data, int flags,
|
2013-10-29 21:38:29 +00:00
|
|
|
double pts)
|
|
|
|
{
|
|
|
|
if (mpctx->paused)
|
|
|
|
return 0;
|
|
|
|
struct ao *ao = mpctx->ao;
|
2014-03-07 14:24:32 +00:00
|
|
|
struct mp_audio out_format;
|
|
|
|
ao_get_format(ao, &out_format);
|
2014-03-07 14:23:03 +00:00
|
|
|
#if HAVE_ENCODING
|
2014-07-16 13:08:06 +00:00
|
|
|
encode_lavc_set_audio_pts(mpctx->encode_lavc_ctx, playing_audio_pts(mpctx));
|
2014-03-07 14:23:03 +00:00
|
|
|
#endif
|
2014-03-09 00:26:24 +00:00
|
|
|
if (data->samples == 0)
|
|
|
|
return 0;
|
2014-03-07 14:24:32 +00:00
|
|
|
double real_samplerate = out_format.rate / mpctx->opts->playback_speed;
|
2013-11-10 22:38:18 +00:00
|
|
|
int played = ao_play(mpctx->ao, data->planes, data->samples, flags);
|
|
|
|
assert(played <= data->samples);
|
2013-10-29 21:38:29 +00:00
|
|
|
if (played > 0) {
|
2013-11-10 22:38:18 +00:00
|
|
|
mpctx->shown_aframes += played;
|
|
|
|
mpctx->delay += played / real_samplerate;
|
2013-10-29 21:38:29 +00:00
|
|
|
return played;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-07-28 18:40:43 +00:00
|
|
|
// Return the number of samples that must be skipped or prepended to reach the
|
|
|
|
// target audio pts after a seek (for A/V sync or hr-seek).
|
|
|
|
// Return value (*skip):
|
|
|
|
// >0: skip this many samples
|
|
|
|
// =0: don't do anything
|
|
|
|
// <0: prepend this many samples of silence
|
|
|
|
// Returns false if PTS is not known yet.
|
|
|
|
static bool get_sync_samples(struct MPContext *mpctx, int *skip)
|
2013-10-29 21:38:29 +00:00
|
|
|
{
|
|
|
|
struct MPOpts *opts = mpctx->opts;
|
2014-07-28 18:40:43 +00:00
|
|
|
*skip = 0;
|
2013-10-29 21:38:29 +00:00
|
|
|
|
2014-07-28 18:40:43 +00:00
|
|
|
if (mpctx->audio_status != STATUS_SYNCING)
|
|
|
|
return true;
|
2013-11-23 20:22:17 +00:00
|
|
|
|
2014-07-28 18:40:43 +00:00
|
|
|
struct mp_audio out_format = {0};
|
|
|
|
ao_get_format(mpctx->ao, &out_format);
|
|
|
|
double play_samplerate = out_format.rate / opts->playback_speed;
|
2014-03-07 14:24:32 +00:00
|
|
|
|
audio: cleanup spdif format definitions
Before this commit, there was AF_FORMAT_AC3 (the original spdif format,
used for AC3 and DTS core), and AF_FORMAT_IEC61937 (used for AC3, DTS
and DTS-HD), which was handled as some sort of superset for
AF_FORMAT_AC3. There also was AF_FORMAT_MPEG2, which used
IEC61937-framing, but still was handled as something "separate".
Technically, all of them are pretty similar, but may use different
bitrates. Since digital passthrough pretends to be PCM (just with
special headers that wrap digital packets), this is easily detectable by
the higher samplerate or higher number of channels, so I don't know why
you'd need a separate "class" of sample formats (AF_FORMAT_AC3 vs.
AF_FORMAT_IEC61937) to distinguish them. Actually, this whole thing is
just a mess.
Simplify this by handling all these formats the same way.
AF_FORMAT_IS_IEC61937() now returns 1 for all spdif formats (even MP3).
All AOs just accept all spdif formats now - whether that works or not is
not really clear (seems inconsistent due to earlier attempts to make
DTS-HD work). But on the other hand, enabling spdif requires manual user
interaction, so it doesn't matter much if initialization fails in
slightly less graceful ways if it can't work at all.
At a later point, we will support passthrough with ao_pulse. It seems
the PulseAudio API wants to know the codec type (or maybe not - feeding
it DTS while telling it it's AC3 works), add separate formats for each
codecs. While this reminds of the earlier chaos, it's stricter, and most
code just uses AF_FORMAT_IS_IEC61937().
Also, modify AF_FORMAT_TYPE_MASK (renamed from AF_FORMAT_POINT_MASK) to
include special formats, so that it always describes the fundamental
sample format type. This also ensures valid AF formats are never 0 (this
was probably broken in one of the earlier commits from today).
2014-09-23 20:44:54 +00:00
|
|
|
bool is_pcm = !AF_FORMAT_IS_SPECIAL(out_format.format); // no spdif
|
2014-07-28 18:40:43 +00:00
|
|
|
if (!opts->initial_audio_sync || !is_pcm) {
|
|
|
|
mpctx->audio_status = STATUS_FILLING;
|
|
|
|
return true;
|
|
|
|
}
|
2013-10-29 21:38:29 +00:00
|
|
|
|
2014-07-28 18:40:43 +00:00
|
|
|
double written_pts = written_audio_pts(mpctx);
|
|
|
|
if (written_pts == MP_NOPTS_VALUE && !mp_audio_buffer_samples(mpctx->ao_buffer))
|
|
|
|
return false; // no audio read yet
|
|
|
|
|
2015-01-28 18:36:46 +00:00
|
|
|
bool sync_to_video = mpctx->d_video && mpctx->sync_audio_to_video &&
|
|
|
|
mpctx->video_status != STATUS_EOF;
|
2014-07-28 18:40:43 +00:00
|
|
|
|
|
|
|
double sync_pts = MP_NOPTS_VALUE;
|
|
|
|
if (sync_to_video) {
|
2015-01-30 22:49:30 +00:00
|
|
|
if (mpctx->video_status < STATUS_READY)
|
2014-07-28 18:40:43 +00:00
|
|
|
return false; // wait until we know a video PTS
|
2015-01-30 22:49:30 +00:00
|
|
|
if (mpctx->video_next_pts != MP_NOPTS_VALUE)
|
|
|
|
sync_pts = mpctx->video_next_pts - (opts->audio_delay - mpctx->delay);
|
2014-07-28 18:40:43 +00:00
|
|
|
} else if (mpctx->hrseek_active) {
|
|
|
|
sync_pts = mpctx->hrseek_pts;
|
2013-10-29 21:38:29 +00:00
|
|
|
}
|
2014-07-28 18:40:43 +00:00
|
|
|
if (sync_pts == MP_NOPTS_VALUE) {
|
|
|
|
mpctx->audio_status = STATUS_FILLING;
|
|
|
|
return true; // syncing disabled
|
2013-10-29 21:38:29 +00:00
|
|
|
}
|
2014-07-28 18:40:43 +00:00
|
|
|
|
|
|
|
double ptsdiff = written_pts - sync_pts;
|
|
|
|
// Missing timestamp, or PTS reset, or just broken.
|
|
|
|
if (written_pts == MP_NOPTS_VALUE || fabs(ptsdiff) > 300) {
|
|
|
|
MP_WARN(mpctx, "Failed audio resync.\n");
|
|
|
|
mpctx->audio_status = STATUS_FILLING;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
*skip = -ptsdiff * play_samplerate;
|
|
|
|
return true;
|
2013-10-29 21:38:29 +00:00
|
|
|
}
|
|
|
|
|
2014-11-08 15:09:42 +00:00
|
|
|
static void do_fill_audio_out_buffers(struct MPContext *mpctx, double endpts)
|
2013-10-29 21:38:29 +00:00
|
|
|
{
|
|
|
|
struct MPOpts *opts = mpctx->opts;
|
2013-11-23 20:22:17 +00:00
|
|
|
struct dec_audio *d_audio = mpctx->d_audio;
|
2013-10-29 21:38:29 +00:00
|
|
|
|
2014-11-09 08:58:44 +00:00
|
|
|
if (mpctx->ao && ao_query_and_reset_events(mpctx->ao, AO_EVENT_RELOAD)) {
|
|
|
|
ao_reset(mpctx->ao);
|
|
|
|
uninit_audio_out(mpctx);
|
2014-11-12 13:15:49 +00:00
|
|
|
if (d_audio)
|
|
|
|
mpctx->audio_status = STATUS_SYNCING;
|
2014-11-09 08:58:44 +00:00
|
|
|
}
|
|
|
|
|
2014-07-30 21:24:08 +00:00
|
|
|
if (!d_audio)
|
|
|
|
return;
|
2013-11-23 20:22:17 +00:00
|
|
|
|
2014-10-01 23:47:27 +00:00
|
|
|
if (d_audio->afilter->initialized < 1 || !mpctx->ao) {
|
2014-07-28 18:40:43 +00:00
|
|
|
// Probe the initial audio format. Returns AD_OK (and does nothing) if
|
|
|
|
// the format is already known.
|
|
|
|
int r = initial_audio_decode(mpctx->d_audio);
|
|
|
|
if (r == AD_WAIT)
|
2014-07-29 22:24:57 +00:00
|
|
|
return; // continue later when new data is available
|
2014-11-09 08:54:39 +00:00
|
|
|
if (r != AD_OK) {
|
|
|
|
mpctx->d_audio->init_retries += 1;
|
|
|
|
if (mpctx->d_audio->init_retries >= 50) {
|
|
|
|
MP_ERR(mpctx, "Error initializing audio.\n");
|
2015-01-15 19:12:51 +00:00
|
|
|
error_on_track(mpctx, mpctx->current_track[0][STREAM_AUDIO]);
|
2014-11-09 08:54:39 +00:00
|
|
|
return;
|
|
|
|
}
|
2014-07-28 18:40:43 +00:00
|
|
|
}
|
|
|
|
reinit_audio_chain(mpctx);
|
2014-10-16 23:10:43 +00:00
|
|
|
mpctx->sleeptime = 0;
|
2014-07-29 22:24:57 +00:00
|
|
|
return; // try again next iteration
|
2013-10-29 21:38:29 +00:00
|
|
|
}
|
|
|
|
|
2014-08-15 21:52:42 +00:00
|
|
|
struct mp_audio out_format = {0};
|
|
|
|
ao_get_format(mpctx->ao, &out_format);
|
|
|
|
double play_samplerate = out_format.rate / opts->playback_speed;
|
|
|
|
|
2014-07-31 02:49:24 +00:00
|
|
|
// If audio is infinitely fast, somehow try keeping approximate A/V sync.
|
|
|
|
if (mpctx->audio_status == STATUS_PLAYING && ao_untimed(mpctx->ao) &&
|
2014-07-31 19:11:49 +00:00
|
|
|
mpctx->video_status != STATUS_EOF && mpctx->delay > 0)
|
2014-07-31 02:49:24 +00:00
|
|
|
return;
|
|
|
|
|
2015-01-30 22:54:43 +00:00
|
|
|
int playsize = ao_get_space(mpctx->ao);
|
2014-07-28 18:40:43 +00:00
|
|
|
|
|
|
|
int skip = 0;
|
|
|
|
bool sync_known = get_sync_samples(mpctx, &skip);
|
|
|
|
if (skip > 0) {
|
|
|
|
playsize = MPMIN(skip + 1, MPMAX(playsize, 2500)); // buffer extra data
|
|
|
|
} else if (skip < 0) {
|
|
|
|
playsize = MPMAX(1, playsize + skip); // silence will be prepended
|
|
|
|
}
|
2013-10-29 21:38:29 +00:00
|
|
|
|
2014-07-28 18:40:43 +00:00
|
|
|
int status = AD_OK;
|
|
|
|
if (playsize > mp_audio_buffer_samples(mpctx->ao_buffer)) {
|
|
|
|
status = audio_decode(d_audio, mpctx->ao_buffer, playsize);
|
|
|
|
if (status == AD_WAIT)
|
2014-07-29 22:24:57 +00:00
|
|
|
return;
|
2014-07-28 18:40:43 +00:00
|
|
|
if (status == AD_NEW_FMT) {
|
2013-10-29 21:38:29 +00:00
|
|
|
/* The format change isn't handled too gracefully. A more precise
|
|
|
|
* implementation would require draining buffered old-format audio
|
|
|
|
* while displaying video, then doing the output format switch.
|
|
|
|
*/
|
2014-06-08 21:54:05 +00:00
|
|
|
if (mpctx->opts->gapless_audio < 1)
|
2014-10-03 17:57:49 +00:00
|
|
|
uninit_audio_out(mpctx);
|
2013-10-29 21:38:29 +00:00
|
|
|
reinit_audio_chain(mpctx);
|
2014-07-28 18:40:43 +00:00
|
|
|
mpctx->sleeptime = 0;
|
2014-07-29 22:24:57 +00:00
|
|
|
return; // retry on next iteration
|
2014-07-28 18:40:43 +00:00
|
|
|
}
|
2015-01-15 20:57:09 +00:00
|
|
|
if (status == AD_ERR)
|
|
|
|
mpctx->sleeptime = 0;
|
2014-07-28 18:40:43 +00:00
|
|
|
}
|
|
|
|
|
2014-07-29 22:40:45 +00:00
|
|
|
// If EOF was reached before, but now something can be decoded, try to
|
|
|
|
// restart audio properly. This helps with video files where audio starts
|
|
|
|
// later. Retrying is needed to get the correct sync PTS.
|
2014-08-31 12:47:05 +00:00
|
|
|
if (mpctx->audio_status >= STATUS_DRAINING && status == AD_OK) {
|
2014-11-27 17:52:22 +00:00
|
|
|
mpctx->audio_status = STATUS_SYNCING;
|
2014-07-29 22:40:45 +00:00
|
|
|
return; // retry on next iteration
|
|
|
|
}
|
|
|
|
|
2014-07-30 20:29:24 +00:00
|
|
|
bool end_sync = false;
|
2014-07-28 18:40:43 +00:00
|
|
|
if (skip >= 0) {
|
|
|
|
int max = mp_audio_buffer_samples(mpctx->ao_buffer);
|
|
|
|
mp_audio_buffer_skip(mpctx->ao_buffer, MPMIN(skip, max));
|
|
|
|
// If something is left, we definitely reached the target time.
|
|
|
|
end_sync |= sync_known && skip < max;
|
|
|
|
} else if (skip < 0) {
|
2014-07-29 22:40:45 +00:00
|
|
|
if (-skip > playsize) { // heuristic against making the buffer too large
|
|
|
|
ao_reset(mpctx->ao); // some AOs repeat data on underflow
|
2014-08-31 12:47:05 +00:00
|
|
|
mpctx->audio_status = STATUS_DRAINING;
|
2014-07-29 22:40:45 +00:00
|
|
|
mpctx->delay = 0;
|
|
|
|
return;
|
2014-07-28 18:40:43 +00:00
|
|
|
}
|
2014-07-29 22:40:45 +00:00
|
|
|
mp_audio_buffer_prepend_silence(mpctx->ao_buffer, -skip);
|
2014-07-28 18:40:43 +00:00
|
|
|
end_sync = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mpctx->audio_status == STATUS_SYNCING) {
|
|
|
|
if (end_sync)
|
|
|
|
mpctx->audio_status = STATUS_FILLING;
|
audio: fix initial sync with huge AO buffer
With e.g --start=-3 --audio-buffer=10 the decoder entered EOF state
before the initial sync was finished, entered STATUS_EOF, and just
started playing audio from a random position.
This doesn't handle seeking outside of the file, which is a different
case. E.g. --start=30:00 with audio and video enabled in a file shorter
than 30:00 will play a random last part of audio. This could perhaps be
fixed by using the hr-seek target for cutting audio, instead of the
video PTS, but that would be kind of intrusive, so don't do it for now.
The simpler solution, assuming audio EOF on video EOF, wouldn't work,
because we allow audio to start before video, or to last after video.
2014-09-06 11:24:44 +00:00
|
|
|
if (status != AD_OK && !mp_audio_buffer_samples(mpctx->ao_buffer))
|
2014-07-30 20:29:24 +00:00
|
|
|
mpctx->audio_status = STATUS_EOF;
|
2014-07-28 18:40:43 +00:00
|
|
|
mpctx->sleeptime = 0;
|
2014-07-29 22:24:57 +00:00
|
|
|
return; // continue on next iteration
|
2014-07-28 18:40:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
assert(mpctx->audio_status >= STATUS_FILLING);
|
|
|
|
|
|
|
|
// Even if we're done decoding and syncing, let video start first - this is
|
|
|
|
// required, because sending audio to the AO already starts playback.
|
|
|
|
if (mpctx->audio_status == STATUS_FILLING && mpctx->sync_audio_to_video &&
|
|
|
|
mpctx->video_status <= STATUS_READY)
|
|
|
|
{
|
|
|
|
mpctx->audio_status = STATUS_READY;
|
2014-07-29 22:24:57 +00:00
|
|
|
return;
|
2013-10-29 21:38:29 +00:00
|
|
|
}
|
|
|
|
|
2014-07-28 18:40:43 +00:00
|
|
|
bool audio_eof = status == AD_EOF;
|
|
|
|
bool partial_fill = false;
|
|
|
|
int playflags = 0;
|
|
|
|
|
audio: respect --end/--length with spdif passthrough
In theory, we can't really do this, because we don't know when a spdif
frame ends. Spdif transports compressed audio through audio setups that
were originally designed for PCM only (which includes the audio filter
chain, the AO API, most audio output APIs, etc.), and to reach this
goal, spdif pretends to be PCM. Compressed data frames are padded with
zeros, until a certain data rate is reached, which corresponds to a
pseudo-PCM format with 2 bytes per sample and 2 channels at 48000 Hz.
Of course an actual spdif frame is significantly larger than a frame
of the PCM format it pretends to be, so cutting audio data on frame
boundaries (as according to the pseudo-PCM format) merely yields an
incomplete and broken frame, not audio that plays for the desired
duration.
However, sending an incomplete frame might still be much better than the
current behavior, which simply ignores --end/--length (but still lets
the video end at the exact end time).
Should this result in trouble with real spdif receivers, this commit
probably has to be reverted.
2013-11-23 20:42:31 +00:00
|
|
|
if (endpts != MP_NOPTS_VALUE) {
|
2015-01-29 11:10:07 +00:00
|
|
|
double samples = (endpts - written_audio_pts(mpctx) - opts->audio_delay)
|
2014-07-28 18:40:43 +00:00
|
|
|
* play_samplerate;
|
2013-11-10 22:38:18 +00:00
|
|
|
if (playsize > samples) {
|
|
|
|
playsize = MPMAX(samples, 0);
|
2013-10-29 21:38:29 +00:00
|
|
|
audio_eof = true;
|
|
|
|
partial_fill = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-07 14:24:32 +00:00
|
|
|
if (playsize > mp_audio_buffer_samples(mpctx->ao_buffer)) {
|
|
|
|
playsize = mp_audio_buffer_samples(mpctx->ao_buffer);
|
2013-10-29 21:38:29 +00:00
|
|
|
partial_fill = true;
|
|
|
|
}
|
2014-07-28 18:40:43 +00:00
|
|
|
|
|
|
|
audio_eof &= partial_fill;
|
|
|
|
|
2014-08-06 17:25:23 +00:00
|
|
|
// With gapless audio, delay this to ao_uninit. There must be only
|
|
|
|
// 1 final chunk, and that is handled when calling ao_uninit().
|
|
|
|
if (audio_eof && !opts->gapless_audio)
|
|
|
|
playflags |= AOPLAY_FINAL_CHUNK;
|
2013-10-29 21:38:29 +00:00
|
|
|
|
2014-03-09 00:26:24 +00:00
|
|
|
if (mpctx->paused)
|
|
|
|
playsize = 0;
|
|
|
|
|
2013-11-10 22:38:18 +00:00
|
|
|
struct mp_audio data;
|
2014-03-07 14:24:32 +00:00
|
|
|
mp_audio_buffer_peek(mpctx->ao_buffer, &data);
|
2013-11-10 22:38:18 +00:00
|
|
|
data.samples = MPMIN(data.samples, playsize);
|
|
|
|
int played = write_to_ao(mpctx, &data, playflags, written_audio_pts(mpctx));
|
2014-02-09 15:21:17 +00:00
|
|
|
assert(played >= 0 && played <= data.samples);
|
2014-05-30 00:14:38 +00:00
|
|
|
mp_audio_buffer_skip(mpctx->ao_buffer, played);
|
2013-10-29 21:38:29 +00:00
|
|
|
|
2014-07-28 18:40:43 +00:00
|
|
|
mpctx->audio_status = STATUS_PLAYING;
|
|
|
|
if (audio_eof) {
|
|
|
|
mpctx->audio_status = STATUS_DRAINING;
|
|
|
|
// Wait until the AO has played all queued data. In the gapless case,
|
|
|
|
// we trigger EOF immediately, and let it play asynchronously.
|
|
|
|
if (ao_eof_reached(mpctx->ao) || opts->gapless_audio)
|
|
|
|
mpctx->audio_status = STATUS_EOF;
|
|
|
|
}
|
2013-10-29 21:38:29 +00:00
|
|
|
}
|
2013-11-08 19:02:09 +00:00
|
|
|
|
2014-11-08 15:09:42 +00:00
|
|
|
void fill_audio_out_buffers(struct MPContext *mpctx, double endpts)
|
|
|
|
{
|
|
|
|
do_fill_audio_out_buffers(mpctx, endpts);
|
|
|
|
// Run audio playback state machine again to display the actual audio PTS
|
|
|
|
// as current time on OSD in audio-only mode in most situations.
|
|
|
|
if (mpctx->audio_status == STATUS_SYNCING)
|
|
|
|
do_fill_audio_out_buffers(mpctx, endpts);
|
|
|
|
}
|
|
|
|
|
2013-11-08 19:02:09 +00:00
|
|
|
// Drop data queued for output, or which the AO is currently outputting.
|
|
|
|
void clear_audio_output_buffers(struct MPContext *mpctx)
|
|
|
|
{
|
2014-10-15 23:03:02 +00:00
|
|
|
if (mpctx->ao)
|
2013-11-08 19:02:09 +00:00
|
|
|
ao_reset(mpctx->ao);
|
2014-10-15 23:03:02 +00:00
|
|
|
if (mpctx->ao_buffer)
|
2014-03-07 14:24:32 +00:00
|
|
|
mp_audio_buffer_clear(mpctx->ao_buffer);
|
2013-11-08 19:02:09 +00:00
|
|
|
}
|