2013-10-29 21:38:29 +00:00
|
|
|
/*
|
2015-04-13 07:36:54 +00:00
|
|
|
* This file is part of mpv.
|
2013-10-29 21:38:29 +00:00
|
|
|
*
|
2015-04-13 07:36:54 +00:00
|
|
|
* mpv is free software; you can redistribute it and/or modify
|
2013-10-29 21:38:29 +00:00
|
|
|
* 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.
|
|
|
|
*
|
2015-04-13 07:36:54 +00:00
|
|
|
* mpv is distributed in the hope that it will be useful,
|
2013-10-29 21:38:29 +00:00
|
|
|
* 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
|
2015-04-13 07:36:54 +00:00
|
|
|
* with mpv. If not, see <http://www.gnu.org/licenses/>.
|
2013-10-29 21:38:29 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#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"
|
2016-01-11 18:03:40 +00:00
|
|
|
#include "mpv_talloc.h"
|
2013-10-29 21:38:29 +00:00
|
|
|
|
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"
|
2015-10-08 21:08:20 +00:00
|
|
|
#include "osdep/timer.h"
|
2013-10-29 21:38:29 +00:00
|
|
|
|
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
|
|
|
|
2016-01-21 21:10:15 +00:00
|
|
|
enum {
|
|
|
|
AD_OK = 0,
|
|
|
|
AD_ERR = -1,
|
|
|
|
AD_EOF = -2,
|
|
|
|
AD_NEW_FMT = -3,
|
|
|
|
AD_WAIT = -4,
|
2016-02-05 22:19:56 +00:00
|
|
|
AD_NO_PROGRESS = -5,
|
2016-01-21 21:10:15 +00:00
|
|
|
};
|
|
|
|
|
2015-11-04 20:31:53 +00:00
|
|
|
// Use pitch correction only for speed adjustments by the user, not minor sync
|
|
|
|
// correction ones.
|
|
|
|
static int get_speed_method(struct MPContext *mpctx)
|
|
|
|
{
|
|
|
|
return mpctx->opts->pitch_correction && mpctx->opts->playback_speed != 1.0
|
|
|
|
? AF_CONTROL_SET_PLAYBACK_SPEED : AF_CONTROL_SET_PLAYBACK_SPEED_RESAMPLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Try to reuse the existing filters to change playback speed. If it works,
|
|
|
|
// return true; if filter recreation is needed, return false.
|
|
|
|
static bool update_speed_filters(struct MPContext *mpctx)
|
2013-10-29 21:38:29 +00:00
|
|
|
{
|
2016-01-21 21:10:15 +00:00
|
|
|
struct af_stream *afs = mpctx->ao_chain->af;
|
2015-11-04 20:31:53 +00:00
|
|
|
double speed = mpctx->audio_speed;
|
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
|
|
|
|
2015-11-04 20:31:53 +00:00
|
|
|
if (afs->initialized < 1)
|
|
|
|
return false;
|
2015-08-10 16:40:16 +00:00
|
|
|
|
2015-03-07 19:14:42 +00:00
|
|
|
// Make sure only exactly one filter changes speed; resetting them all
|
|
|
|
// and setting 1 filter is the easiest way to achieve this.
|
|
|
|
af_control_all(afs, AF_CONTROL_SET_PLAYBACK_SPEED, &(double){1});
|
|
|
|
af_control_all(afs, AF_CONTROL_SET_PLAYBACK_SPEED_RESAMPLE, &(double){1});
|
|
|
|
|
|
|
|
if (speed == 1.0)
|
2015-11-04 20:31:53 +00:00
|
|
|
return !af_find_by_label(afs, "playback-speed");
|
2014-11-10 19:16:25 +00:00
|
|
|
|
2015-03-07 19:14:42 +00:00
|
|
|
// Compatibility: if the user uses --af=scaletempo, always use this
|
|
|
|
// filter to change speed. Don't insert a second filter (any) either.
|
|
|
|
if (!af_find_by_label(afs, "playback-speed") &&
|
|
|
|
af_control_any_rev(afs, AF_CONTROL_SET_PLAYBACK_SPEED, &speed))
|
2015-11-04 20:31:53 +00:00
|
|
|
return true;
|
2015-03-07 19:14:42 +00:00
|
|
|
|
2015-11-04 20:31:53 +00:00
|
|
|
return !!af_control_any_rev(afs, get_speed_method(mpctx), &speed);
|
|
|
|
}
|
2015-03-07 19:14:42 +00:00
|
|
|
|
2015-11-04 20:31:53 +00:00
|
|
|
// Update speed, and insert/remove filters if necessary.
|
|
|
|
static void recreate_speed_filters(struct MPContext *mpctx)
|
|
|
|
{
|
2016-01-21 21:10:15 +00:00
|
|
|
struct af_stream *afs = mpctx->ao_chain->af;
|
2015-11-04 20:31:53 +00:00
|
|
|
|
|
|
|
if (update_speed_filters(mpctx))
|
|
|
|
return;
|
2015-03-07 19:14:42 +00:00
|
|
|
|
2015-11-04 20:31:53 +00:00
|
|
|
if (af_remove_by_label(afs, "playback-speed") < 0)
|
|
|
|
goto fail;
|
2014-10-01 23:47:27 +00:00
|
|
|
|
2015-11-04 20:31:53 +00:00
|
|
|
if (mpctx->audio_speed == 1.0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
int method = get_speed_method(mpctx);
|
|
|
|
char *filter = method == AF_CONTROL_SET_PLAYBACK_SPEED
|
|
|
|
? "scaletempo" : "lavrresample";
|
|
|
|
|
|
|
|
if (!af_add(afs, filter, "playback-speed", NULL))
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
if (!update_speed_filters(mpctx))
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
fail:
|
|
|
|
mpctx->opts->playback_speed = 1.0;
|
|
|
|
mpctx->speed_factor_a = 1.0;
|
|
|
|
mpctx->audio_speed = 1.0;
|
|
|
|
mp_notify(mpctx, MP_EVENT_CHANGE_ALL, NULL);
|
2015-03-07 19:14:42 +00:00
|
|
|
}
|
|
|
|
|
2017-04-26 19:45:50 +00:00
|
|
|
// Convert to gain value from dB. input <= -200dB will become 0 gain.
|
|
|
|
// Copyright (C)2002 Anders Johansson
|
|
|
|
static float from_dB(float in, float k, float mi, float ma)
|
|
|
|
{
|
|
|
|
if (in <= -200)
|
|
|
|
return 0.0;
|
|
|
|
return pow(10.0, MPCLAMP(in, mi, ma) / k);
|
|
|
|
}
|
|
|
|
|
|
|
|
static float compute_replaygain(struct MPContext *mpctx)
|
|
|
|
{
|
|
|
|
struct MPOpts *opts = mpctx->opts;
|
|
|
|
struct ao_chain *ao_c = mpctx->ao_chain;
|
|
|
|
|
|
|
|
float rgain = 1.0;
|
|
|
|
|
|
|
|
struct replaygain_data *rg = ao_c->af->replaygain_data;
|
2017-04-26 22:21:17 +00:00
|
|
|
if (opts->rgain_mode && rg) {
|
2017-04-26 19:45:50 +00:00
|
|
|
MP_VERBOSE(mpctx, "Replaygain: Track=%f/%f Album=%f/%f\n",
|
|
|
|
rg->track_gain, rg->track_peak,
|
|
|
|
rg->album_gain, rg->album_peak);
|
|
|
|
|
|
|
|
float gain, peak;
|
2017-04-26 22:21:17 +00:00
|
|
|
if (opts->rgain_mode == 1) {
|
2017-04-26 19:45:50 +00:00
|
|
|
gain = rg->track_gain;
|
|
|
|
peak = rg->track_peak;
|
|
|
|
} else {
|
|
|
|
gain = rg->album_gain;
|
|
|
|
peak = rg->album_peak;
|
|
|
|
}
|
|
|
|
|
|
|
|
gain += opts->rgain_preamp;
|
|
|
|
rgain = from_dB(gain, 20.0, -200.0, 60.0);
|
|
|
|
|
|
|
|
MP_VERBOSE(mpctx, "Applying replay-gain: %f\n", rgain);
|
|
|
|
|
|
|
|
if (!opts->rgain_clip) { // clipping prevention
|
|
|
|
rgain = MPMIN(rgain, 1.0 / peak);
|
|
|
|
MP_VERBOSE(mpctx, "...with clipping prevention: %f\n", rgain);
|
|
|
|
}
|
|
|
|
} else if (opts->rgain_fallback) {
|
|
|
|
rgain = from_dB(opts->rgain_fallback, 20.0, -200.0, 60.0);
|
|
|
|
MP_VERBOSE(mpctx, "Applying fallback gain: %f\n", rgain);
|
|
|
|
}
|
|
|
|
|
|
|
|
return rgain;
|
|
|
|
}
|
|
|
|
|
2016-07-17 17:21:28 +00:00
|
|
|
// Called when opts->softvol_volume or opts->softvol_mute were changed.
|
|
|
|
void audio_update_volume(struct MPContext *mpctx)
|
|
|
|
{
|
|
|
|
struct MPOpts *opts = mpctx->opts;
|
|
|
|
struct ao_chain *ao_c = mpctx->ao_chain;
|
|
|
|
if (!ao_c || ao_c->af->initialized < 1)
|
|
|
|
return;
|
|
|
|
|
|
|
|
float gain = MPMAX(opts->softvol_volume / 100.0, 0);
|
2017-04-26 22:15:22 +00:00
|
|
|
gain = pow(gain, 3);
|
2017-04-26 19:45:50 +00:00
|
|
|
gain *= compute_replaygain(mpctx);
|
2016-07-17 17:21:28 +00:00
|
|
|
if (opts->softvol_mute == 1)
|
|
|
|
gain = 0.0;
|
|
|
|
|
|
|
|
if (!af_control_any_rev(ao_c->af, AF_CONTROL_SET_VOLUME, &gain)) {
|
|
|
|
if (gain == 1.0)
|
|
|
|
return;
|
|
|
|
MP_VERBOSE(mpctx, "Inserting volume filter.\n");
|
2017-04-04 13:04:07 +00:00
|
|
|
char *args[] = {"warn", "no", NULL};
|
|
|
|
if (!(af_add(ao_c->af, "volume", "softvol", args)
|
2016-07-17 17:21:28 +00:00
|
|
|
&& af_control_any_rev(ao_c->af, AF_CONTROL_SET_VOLUME, &gain)))
|
|
|
|
MP_ERR(mpctx, "No volume control available.\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* NOTE: Currently the balance code is seriously buggy: it always changes
|
|
|
|
* the af_pan mapping between the first two input channels and first two
|
|
|
|
* output channels to particular values. These values make sense for an
|
|
|
|
* af_pan instance that was automatically inserted for balance control
|
|
|
|
* only and is otherwise an identity transform, but if the filter was
|
|
|
|
* there for another reason, then ignoring and overriding the original
|
|
|
|
* values is completely wrong.
|
|
|
|
*/
|
|
|
|
void audio_update_balance(struct MPContext *mpctx)
|
|
|
|
{
|
|
|
|
struct MPOpts *opts = mpctx->opts;
|
|
|
|
struct ao_chain *ao_c = mpctx->ao_chain;
|
|
|
|
if (!ao_c || ao_c->af->initialized < 1)
|
|
|
|
return;
|
|
|
|
|
|
|
|
float val = opts->balance;
|
|
|
|
|
|
|
|
if (af_control_any_rev(ao_c->af, AF_CONTROL_SET_PAN_BALANCE, &val))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (val == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
struct af_instance *af_pan_balance;
|
|
|
|
if (!(af_pan_balance = af_add(ao_c->af, "pan", "autopan", NULL))) {
|
|
|
|
MP_ERR(mpctx, "No balance control available.\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* make all other channels pass through since by default pan blocks all */
|
|
|
|
for (int i = 2; i < AF_NCH; i++) {
|
|
|
|
float level[AF_NCH] = {0};
|
|
|
|
level[i] = 1.f;
|
|
|
|
af_control_ext_t arg_ext = { .ch = i, .arg = level };
|
|
|
|
af_pan_balance->control(af_pan_balance, AF_CONTROL_SET_PAN_LEVEL,
|
|
|
|
&arg_ext);
|
|
|
|
}
|
|
|
|
|
|
|
|
af_pan_balance->control(af_pan_balance, AF_CONTROL_SET_PAN_BALANCE, &val);
|
|
|
|
}
|
|
|
|
|
2015-03-07 19:14:42 +00:00
|
|
|
static int recreate_audio_filters(struct MPContext *mpctx)
|
|
|
|
{
|
2016-01-21 21:10:15 +00:00
|
|
|
assert(mpctx->ao_chain);
|
2015-03-07 19:14:42 +00:00
|
|
|
|
2016-01-21 21:10:15 +00:00
|
|
|
struct af_stream *afs = mpctx->ao_chain->af;
|
2015-11-04 20:31:53 +00:00
|
|
|
if (afs->initialized < 1 && af_init(afs) < 0)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
recreate_speed_filters(mpctx);
|
|
|
|
if (afs->initialized < 1 && af_init(afs) < 0)
|
|
|
|
goto fail;
|
2013-10-29 21:38:29 +00:00
|
|
|
|
2016-07-17 17:21:28 +00:00
|
|
|
if (mpctx->opts->softvol == SOFTVOL_NO)
|
|
|
|
MP_ERR(mpctx, "--softvol=no is not supported anymore.\n");
|
|
|
|
|
|
|
|
audio_update_volume(mpctx);
|
|
|
|
audio_update_balance(mpctx);
|
2013-10-29 21:38:29 +00:00
|
|
|
|
2016-03-13 14:52:17 +00:00
|
|
|
mp_notify(mpctx, MPV_EVENT_AUDIO_RECONFIG, NULL);
|
|
|
|
|
2013-10-29 21:38:29 +00:00
|
|
|
return 0;
|
2015-11-04 20:31:53 +00:00
|
|
|
|
|
|
|
fail:
|
|
|
|
MP_ERR(mpctx, "Couldn't find matching filter/ao format!\n");
|
|
|
|
return -1;
|
2013-10-29 21:38:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int reinit_audio_filters(struct MPContext *mpctx)
|
|
|
|
{
|
2016-01-21 21:10:15 +00:00
|
|
|
struct ao_chain *ao_c = mpctx->ao_chain;
|
|
|
|
if (!ao_c)
|
2014-03-30 17:21:54 +00:00
|
|
|
return 0;
|
2013-10-29 21:38:29 +00:00
|
|
|
|
2016-02-09 21:19:01 +00:00
|
|
|
double delay = 0;
|
|
|
|
if (ao_c->af->initialized > 0)
|
|
|
|
delay = af_calc_delay(ao_c->af);
|
|
|
|
|
2016-01-21 21:10:15 +00:00
|
|
|
af_uninit(ao_c->af);
|
2016-02-09 21:19:01 +00:00
|
|
|
if (recreate_audio_filters(mpctx) < 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
// Only force refresh if the amount of dropped buffered data is going to
|
|
|
|
// cause "issues" for the A/V sync logic.
|
|
|
|
if (mpctx->audio_status == STATUS_PLAYING &&
|
|
|
|
mpctx->playback_pts != MP_NOPTS_VALUE && delay > 0.2)
|
|
|
|
{
|
|
|
|
queue_seek(mpctx, MPSEEK_ABSOLUTE, mpctx->playback_pts,
|
2016-08-15 19:07:32 +00:00
|
|
|
MPSEEK_EXACT, 0);
|
2016-02-09 21:19:01 +00:00
|
|
|
}
|
|
|
|
return 1;
|
2013-10-29 21:38:29 +00:00
|
|
|
}
|
|
|
|
|
2015-11-04 20:31:53 +00:00
|
|
|
// Call this if opts->playback_speed or mpctx->speed_factor_* change.
|
2015-08-10 16:40:16 +00:00
|
|
|
void update_playback_speed(struct MPContext *mpctx)
|
2014-10-02 00:49:05 +00:00
|
|
|
{
|
2015-11-04 20:31:53 +00:00
|
|
|
mpctx->audio_speed = mpctx->opts->playback_speed * mpctx->speed_factor_a;
|
|
|
|
mpctx->video_speed = mpctx->opts->playback_speed * mpctx->speed_factor_v;
|
2014-10-02 00:49:05 +00:00
|
|
|
|
2016-01-21 21:10:15 +00:00
|
|
|
if (!mpctx->ao_chain || mpctx->ao_chain->af->initialized < 1)
|
2014-10-02 00:58:52 +00:00
|
|
|
return;
|
|
|
|
|
2015-11-04 20:31:53 +00:00
|
|
|
if (!update_speed_filters(mpctx))
|
|
|
|
recreate_audio_filters(mpctx);
|
2014-10-02 00:49:05 +00:00
|
|
|
}
|
|
|
|
|
2016-01-21 21:24:20 +00:00
|
|
|
static void ao_chain_reset_state(struct ao_chain *ao_c)
|
|
|
|
{
|
|
|
|
ao_c->pts = MP_NOPTS_VALUE;
|
2016-01-29 21:44:20 +00:00
|
|
|
ao_c->pts_reset = false;
|
2016-01-25 12:41:28 +00:00
|
|
|
talloc_free(ao_c->input_frame);
|
|
|
|
ao_c->input_frame = NULL;
|
2016-01-21 21:24:20 +00:00
|
|
|
af_seek_reset(ao_c->af);
|
2016-01-21 21:41:41 +00:00
|
|
|
mp_audio_buffer_clear(ao_c->ao_buffer);
|
2016-01-29 21:46:28 +00:00
|
|
|
|
|
|
|
if (ao_c->audio_src)
|
|
|
|
audio_reset_decoding(ao_c->audio_src);
|
2016-01-21 21:24:20 +00:00
|
|
|
}
|
|
|
|
|
2014-07-30 21:01:55 +00:00
|
|
|
void reset_audio_state(struct MPContext *mpctx)
|
|
|
|
{
|
2016-01-29 21:46:28 +00:00
|
|
|
if (mpctx->ao_chain)
|
2016-01-21 21:24:20 +00:00
|
|
|
ao_chain_reset_state(mpctx->ao_chain);
|
2016-01-21 21:10:15 +00:00
|
|
|
mpctx->audio_status = mpctx->ao_chain ? STATUS_SYNCING : STATUS_EOF;
|
2015-01-30 22:49:30 +00:00
|
|
|
mpctx->delay = 0;
|
2015-11-03 19:29:25 +00:00
|
|
|
mpctx->audio_drop_throttle = 0;
|
2015-10-08 21:08:20 +00:00
|
|
|
mpctx->audio_stat_start = 0;
|
player: gross hack to improve non-hr seeking with external audio tracks
Relative seeks backwards with external audio tracks does not always work
well: it tends to happen that video seek back further than audio, so
audio will remain silent until the audio's after-seek position is
reached. This happens because we strictly seek both video and audio
demuxer to the approximate desirted target PTS, and then start decoding
from that.
Commit 81358380 removes an older method that was supposed to deal with
this. It was sort of bad, because it could lead to the playback core
freezing by waiting on network.
Ideally, the demuxer layer would probably somehow deal with such seeks,
and do them in a way the audio is seeked after video. Currently this is
infeasible, because the demuxer layer assumes a single demuxer, and
external tracks simply use separate demuxer layers. (MPlayer actually
had a pseudo-demuxer that joined external tracks into a single demuxer,
but this is not flexible enough - and also, the demuxer layer as it
currently exists can't deal with dynamically removing external tracks
either. Maybe some time in the future.)
Instead, add a gross hack, that essentially reseeks the audio if it
detects that it's too far off. The result is actually not too bad,
because we can reuse the mechanism that is used for instant track
switching. This way we can make sure of the right position, without
having to care about certain other issues.
It should be noted that if the audio demuxer is used for other tracks
too, and the demuxer does not support refresh seeking, audio will
probably be off by even a higher amount. But this should be rare.
2016-08-07 14:29:13 +00:00
|
|
|
mpctx->audio_allow_second_chance_seek = false;
|
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);
|
|
|
|
ao_uninit(mpctx->ao);
|
2015-06-09 16:29:11 +00:00
|
|
|
|
|
|
|
mp_notify(mpctx, MPV_EVENT_AUDIO_RECONFIG, NULL);
|
2014-10-03 17:57:49 +00:00
|
|
|
}
|
|
|
|
mpctx->ao = NULL;
|
|
|
|
talloc_free(mpctx->ao_decoder_fmt);
|
|
|
|
mpctx->ao_decoder_fmt = NULL;
|
|
|
|
}
|
|
|
|
|
2016-01-21 21:24:20 +00:00
|
|
|
static void ao_chain_uninit(struct ao_chain *ao_c)
|
|
|
|
{
|
2016-02-05 22:19:56 +00:00
|
|
|
struct track *track = ao_c->track;
|
|
|
|
if (track) {
|
|
|
|
assert(track->ao_c == ao_c);
|
|
|
|
track->ao_c = NULL;
|
|
|
|
assert(track->d_audio == ao_c->audio_src);
|
|
|
|
track->d_audio = NULL;
|
|
|
|
audio_uninit(ao_c->audio_src);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ao_c->filter_src)
|
|
|
|
lavfi_set_connected(ao_c->filter_src, false);
|
|
|
|
|
2016-01-21 21:24:20 +00:00
|
|
|
af_destroy(ao_c->af);
|
2016-01-23 10:41:19 +00:00
|
|
|
talloc_free(ao_c->input_frame);
|
2016-01-21 21:41:41 +00:00
|
|
|
talloc_free(ao_c->ao_buffer);
|
2016-01-21 21:24:20 +00:00
|
|
|
talloc_free(ao_c);
|
|
|
|
}
|
|
|
|
|
2014-10-03 17:57:49 +00:00
|
|
|
void uninit_audio_chain(struct MPContext *mpctx)
|
|
|
|
{
|
2016-01-21 21:10:15 +00:00
|
|
|
if (mpctx->ao_chain) {
|
2016-01-21 21:24:20 +00:00
|
|
|
ao_chain_uninit(mpctx->ao_chain);
|
2016-01-21 21:10:15 +00:00
|
|
|
mpctx->ao_chain = NULL;
|
2016-02-05 22:19:56 +00:00
|
|
|
|
2014-10-03 17:57:49 +00:00
|
|
|
mpctx->audio_status = STATUS_EOF;
|
2015-06-09 16:29:11 +00:00
|
|
|
|
|
|
|
mp_notify(mpctx, MPV_EVENT_AUDIO_RECONFIG, NULL);
|
2014-10-03 17:57:49 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-29 21:44:35 +00:00
|
|
|
static void reinit_audio_filters_and_output(struct MPContext *mpctx)
|
2013-10-29 21:38:29 +00:00
|
|
|
{
|
|
|
|
struct MPOpts *opts = mpctx->opts;
|
2016-01-21 21:10:15 +00:00
|
|
|
struct ao_chain *ao_c = mpctx->ao_chain;
|
2016-01-29 21:44:35 +00:00
|
|
|
assert(ao_c);
|
2016-02-05 22:41:44 +00:00
|
|
|
struct track *track = ao_c->track;
|
2016-01-29 21:44:35 +00:00
|
|
|
struct af_stream *afs = ao_c->af;
|
2013-10-29 21:38:29 +00:00
|
|
|
|
2016-01-29 21:46:28 +00:00
|
|
|
if (ao_c->input_frame)
|
|
|
|
mp_audio_copy_config(&ao_c->input_format, ao_c->input_frame);
|
|
|
|
|
2016-01-21 21:10:15 +00:00
|
|
|
struct mp_audio in_format = ao_c->input_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.
|
2016-09-16 12:24:15 +00:00
|
|
|
mp_wakeup_core(mpctx);
|
2014-07-28 18:40:43 +00:00
|
|
|
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
|
|
|
}
|
|
|
|
|
2016-01-29 21:44:35 +00:00
|
|
|
if (mpctx->ao && mp_audio_config_equals(&in_format, &afs->input))
|
|
|
|
return;
|
2014-10-01 23:47:27 +00:00
|
|
|
|
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-06-26 21:06:37 +00:00
|
|
|
} else if (af_fmt_is_pcm(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);
|
2016-08-04 18:49:20 +00:00
|
|
|
if (opts->audio_output_channels.num_chmaps == 1) {
|
|
|
|
mp_audio_set_channels(&afs->output,
|
|
|
|
&opts->audio_output_channels.chmaps[0]);
|
|
|
|
}
|
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) {
|
2016-08-04 18:49:20 +00:00
|
|
|
int ao_flags = 0;
|
2015-10-05 16:53:02 +00:00
|
|
|
bool spdif_fallback = af_fmt_is_spdif(afs->output.format) &&
|
2016-01-21 21:10:15 +00:00
|
|
|
ao_c->spdif_passthrough;
|
2016-08-04 18:49:20 +00:00
|
|
|
|
|
|
|
if (opts->ao_null_fallback && !spdif_fallback)
|
|
|
|
ao_flags |= AO_INIT_NULL_FALLBACK;
|
|
|
|
|
2016-08-09 14:22:06 +00:00
|
|
|
if (opts->audio_stream_silence)
|
|
|
|
ao_flags |= AO_INIT_STREAM_SILENCE;
|
|
|
|
|
2016-09-05 19:07:34 +00:00
|
|
|
if (opts->audio_exclusive)
|
|
|
|
ao_flags |= AO_INIT_EXCLUSIVE;
|
|
|
|
|
2016-08-22 10:12:10 +00:00
|
|
|
if (af_fmt_is_pcm(afs->output.format)) {
|
|
|
|
if (!opts->audio_output_channels.set ||
|
|
|
|
opts->audio_output_channels.auto_safe)
|
|
|
|
ao_flags |= AO_INIT_SAFE_MULTICHANNEL_ONLY;
|
|
|
|
|
|
|
|
mp_chmap_sel_list(&afs->output.channels,
|
|
|
|
opts->audio_output_channels.chmaps,
|
|
|
|
opts->audio_output_channels.num_chmaps);
|
|
|
|
}
|
2015-10-05 16:53:02 +00:00
|
|
|
|
2014-10-01 23:47:27 +00:00
|
|
|
mp_audio_set_channels(&afs->output, &afs->output.channels);
|
|
|
|
|
2016-09-16 12:23:54 +00:00
|
|
|
mpctx->ao = ao_init_best(mpctx->global, ao_flags, mp_wakeup_core_cb,
|
|
|
|
mpctx, mpctx->encode_lavc_ctx, afs->output.rate,
|
2014-10-01 23:47:27 +00:00
|
|
|
afs->output.format, afs->output.channels);
|
2016-01-21 21:10:15 +00:00
|
|
|
ao_c->ao = mpctx->ao;
|
2015-06-05 20:34:22 +00:00
|
|
|
|
|
|
|
struct mp_audio fmt = {0};
|
|
|
|
if (mpctx->ao)
|
|
|
|
ao_get_format(mpctx->ao, &fmt);
|
|
|
|
|
|
|
|
// Verify passthrough format was not changed.
|
2015-06-26 21:06:37 +00:00
|
|
|
if (mpctx->ao && af_fmt_is_spdif(afs->output.format)) {
|
2015-06-05 20:34:22 +00:00
|
|
|
if (!mp_audio_config_equals(&afs->output, &fmt)) {
|
|
|
|
MP_ERR(mpctx, "Passthrough format unsupported.\n");
|
|
|
|
ao_uninit(mpctx->ao);
|
|
|
|
mpctx->ao = NULL;
|
2016-01-21 21:10:15 +00:00
|
|
|
ao_c->ao = NULL;
|
2015-06-05 20:34:22 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!mpctx->ao) {
|
2015-06-05 20:35:43 +00:00
|
|
|
// If spdif was used, try to fallback to PCM.
|
2016-01-29 21:46:28 +00:00
|
|
|
if (spdif_fallback && ao_c->audio_src) {
|
2016-01-25 12:43:43 +00:00
|
|
|
MP_VERBOSE(mpctx, "Falling back to PCM output.\n");
|
2016-01-21 21:10:15 +00:00
|
|
|
ao_c->spdif_passthrough = false;
|
|
|
|
ao_c->spdif_failed = true;
|
2016-01-21 21:24:20 +00:00
|
|
|
ao_c->audio_src->try_spdif = false;
|
|
|
|
if (!audio_init_best_codec(ao_c->audio_src))
|
2015-06-05 20:35:43 +00:00
|
|
|
goto init_error;
|
|
|
|
reset_audio_state(mpctx);
|
2016-01-25 12:43:43 +00:00
|
|
|
ao_c->input_format = (struct mp_audio){0};
|
2016-09-16 12:24:15 +00:00
|
|
|
mp_wakeup_core(mpctx); // reinit with new format next time
|
2015-06-05 20:35:43 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-10-29 21:38:29 +00:00
|
|
|
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
|
|
|
|
2016-01-21 21:41:41 +00:00
|
|
|
mp_audio_buffer_reinit(ao_c->ao_buffer, &fmt);
|
2014-10-01 23:47:27 +00:00
|
|
|
afs->output = fmt;
|
2015-04-07 11:38:03 +00:00
|
|
|
if (!mp_audio_config_equals(&afs->output, &afs->filter_output))
|
|
|
|
afs->initialized = 0;
|
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;
|
|
|
|
|
2015-06-05 20:34:22 +00:00
|
|
|
MP_INFO(mpctx, "AO: [%s] %s\n", ao_get_name(mpctx->ao),
|
2014-11-25 10:11:31 +00:00
|
|
|
mp_audio_config_to_str(&fmt));
|
2015-06-05 20:34:22 +00:00
|
|
|
MP_VERBOSE(mpctx, "AO: Description: %s\n", ao_get_description(mpctx->ao));
|
2013-11-09 23:49:13 +00:00
|
|
|
update_window_title(mpctx, true);
|
2016-08-09 14:26:44 +00:00
|
|
|
|
|
|
|
ao_c->ao_resume_time =
|
|
|
|
opts->audio_wait_open > 0 ? mp_time_sec() + opts->audio_wait_open : 0;
|
2013-10-29 21:38:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (recreate_audio_filters(mpctx) < 0)
|
|
|
|
goto init_error;
|
|
|
|
|
2015-08-10 16:40:16 +00:00
|
|
|
update_playback_speed(mpctx);
|
2014-10-02 00:58:52 +00:00
|
|
|
|
2016-03-13 14:52:17 +00:00
|
|
|
mp_notify(mpctx, MPV_EVENT_AUDIO_RECONFIG, NULL);
|
|
|
|
|
2013-10-29 21:38:29 +00:00
|
|
|
return;
|
|
|
|
|
2016-01-29 21:44:35 +00:00
|
|
|
init_error:
|
|
|
|
uninit_audio_chain(mpctx);
|
|
|
|
uninit_audio_out(mpctx);
|
2016-02-05 22:41:44 +00:00
|
|
|
error_on_track(mpctx, track);
|
2016-01-29 21:44:35 +00:00
|
|
|
}
|
|
|
|
|
2016-02-05 20:50:37 +00:00
|
|
|
int init_audio_decoder(struct MPContext *mpctx, struct track *track)
|
|
|
|
{
|
|
|
|
assert(!track->d_audio);
|
|
|
|
if (!track->stream)
|
|
|
|
goto init_error;
|
|
|
|
|
|
|
|
track->d_audio = talloc_zero(NULL, struct dec_audio);
|
|
|
|
struct dec_audio *d_audio = track->d_audio;
|
|
|
|
d_audio->log = mp_log_new(d_audio, mpctx->log, "!ad");
|
|
|
|
d_audio->global = mpctx->global;
|
|
|
|
d_audio->opts = mpctx->opts;
|
|
|
|
d_audio->header = track->stream;
|
2016-02-15 19:34:45 +00:00
|
|
|
d_audio->codec = track->stream->codec;
|
2016-02-05 20:50:37 +00:00
|
|
|
|
|
|
|
d_audio->try_spdif = true;
|
|
|
|
|
|
|
|
if (!audio_init_best_codec(d_audio))
|
|
|
|
goto init_error;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
init_error:
|
2016-02-05 22:19:56 +00:00
|
|
|
if (track->sink)
|
|
|
|
lavfi_set_connected(track->sink, false);
|
|
|
|
track->sink = NULL;
|
2016-02-05 20:50:37 +00:00
|
|
|
audio_uninit(track->d_audio);
|
|
|
|
track->d_audio = NULL;
|
|
|
|
error_on_track(mpctx, track);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-01-29 21:44:35 +00:00
|
|
|
void reinit_audio_chain(struct MPContext *mpctx)
|
|
|
|
{
|
2016-02-05 22:19:56 +00:00
|
|
|
reinit_audio_chain_src(mpctx, NULL);
|
|
|
|
}
|
2016-01-29 21:44:35 +00:00
|
|
|
|
2016-02-05 22:19:56 +00:00
|
|
|
void reinit_audio_chain_src(struct MPContext *mpctx, struct lavfi_pad *src)
|
|
|
|
{
|
|
|
|
struct track *track = NULL;
|
|
|
|
struct sh_stream *sh = NULL;
|
|
|
|
if (!src) {
|
|
|
|
track = mpctx->current_track[0][STREAM_AUDIO];
|
2017-04-16 09:02:30 +00:00
|
|
|
if (!track) {
|
|
|
|
uninit_audio_out(mpctx);
|
2016-02-05 22:19:56 +00:00
|
|
|
return;
|
2017-04-16 09:02:30 +00:00
|
|
|
}
|
2016-02-12 15:05:46 +00:00
|
|
|
sh = track->stream;
|
2016-02-05 22:19:56 +00:00
|
|
|
if (!sh) {
|
|
|
|
uninit_audio_out(mpctx);
|
|
|
|
goto no_audio;
|
|
|
|
}
|
2016-01-29 21:44:35 +00:00
|
|
|
}
|
2016-02-05 22:19:56 +00:00
|
|
|
assert(!mpctx->ao_chain);
|
2016-01-29 21:44:35 +00:00
|
|
|
|
|
|
|
mp_notify(mpctx, MPV_EVENT_AUDIO_RECONFIG, NULL);
|
|
|
|
|
2016-02-12 15:00:14 +00:00
|
|
|
struct ao_chain *ao_c = talloc_zero(NULL, struct ao_chain);
|
2016-01-29 21:44:35 +00:00
|
|
|
mpctx->ao_chain = ao_c;
|
|
|
|
ao_c->log = mpctx->log;
|
|
|
|
ao_c->af = af_new(mpctx->global);
|
2016-02-05 22:19:56 +00:00
|
|
|
if (sh)
|
|
|
|
ao_c->af->replaygain_data = sh->codec->replaygain_data;
|
2016-01-29 21:44:35 +00:00
|
|
|
ao_c->spdif_passthrough = true;
|
|
|
|
ao_c->pts = MP_NOPTS_VALUE;
|
2016-02-05 20:50:37 +00:00
|
|
|
ao_c->ao_buffer = mp_audio_buffer_create(NULL);
|
2016-01-29 21:44:35 +00:00
|
|
|
ao_c->ao = mpctx->ao;
|
|
|
|
|
2016-02-05 22:19:56 +00:00
|
|
|
ao_c->filter_src = src;
|
|
|
|
if (!ao_c->filter_src) {
|
|
|
|
ao_c->track = track;
|
|
|
|
track->ao_c = ao_c;
|
|
|
|
if (!init_audio_decoder(mpctx, track))
|
|
|
|
goto init_error;
|
|
|
|
ao_c->audio_src = track->d_audio;
|
|
|
|
}
|
2016-01-29 21:44:35 +00:00
|
|
|
|
|
|
|
reset_audio_state(mpctx);
|
|
|
|
|
|
|
|
if (mpctx->ao) {
|
|
|
|
struct mp_audio fmt;
|
|
|
|
ao_get_format(mpctx->ao, &fmt);
|
|
|
|
mp_audio_buffer_reinit(ao_c->ao_buffer, &fmt);
|
|
|
|
}
|
|
|
|
|
2016-09-16 12:24:15 +00:00
|
|
|
mp_wakeup_core(mpctx);
|
2016-01-29 21:44:35 +00:00
|
|
|
return;
|
|
|
|
|
2013-10-29 21:38:29 +00:00
|
|
|
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:
|
2016-02-05 22:41:44 +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)
|
|
|
|
{
|
2016-01-21 21:10:15 +00:00
|
|
|
struct ao_chain *ao_c = mpctx->ao_chain;
|
|
|
|
if (!ao_c)
|
2013-10-29 21:38:29 +00:00
|
|
|
return MP_NOPTS_VALUE;
|
|
|
|
|
2016-01-21 21:10:15 +00:00
|
|
|
struct mp_audio in_format = ao_c->input_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
|
|
|
|
2016-01-21 21:10:15 +00:00
|
|
|
if (!mp_audio_config_valid(&in_format) || ao_c->af->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
|
2016-01-21 21:10:15 +00:00
|
|
|
double a_pts = ao_c->pts;
|
2013-10-29 21:38:29 +00:00
|
|
|
if (a_pts == MP_NOPTS_VALUE)
|
|
|
|
return MP_NOPTS_VALUE;
|
|
|
|
|
2013-11-10 22:38:18 +00:00
|
|
|
// Data buffered in audio filters, measured in seconds of "missing" output
|
2016-01-21 21:10:15 +00:00
|
|
|
double buffered_output = af_calc_delay(ao_c->af);
|
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
|
2016-01-21 21:41:41 +00:00
|
|
|
buffered_output += mp_audio_buffer_seconds(ao_c->ao_buffer);
|
2013-10-29 21:38:29 +00:00
|
|
|
|
2015-08-10 16:40:16 +00:00
|
|
|
// Filters divide audio length by audio_speed, so multiply by it
|
2013-10-29 21:38:29 +00:00
|
|
|
// to get the length in original units without speedup or slowdown
|
2015-08-10 16:40:16 +00:00
|
|
|
a_pts -= buffered_output * mpctx->audio_speed;
|
2013-10-29 21:38:29 +00:00
|
|
|
|
2015-11-16 22:15:59 +00:00
|
|
|
return a_pts;
|
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;
|
2015-08-10 16:40:16 +00:00
|
|
|
return pts - mpctx->audio_speed * ao_get_delay(mpctx->ao);
|
2013-10-29 21:38:29 +00:00
|
|
|
}
|
|
|
|
|
2015-07-24 15:27:40 +00:00
|
|
|
static int write_to_ao(struct MPContext *mpctx, struct mp_audio *data, int flags)
|
2013-10-29 21:38:29 +00:00
|
|
|
{
|
|
|
|
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;
|
2015-08-10 16:40:16 +00:00
|
|
|
double real_samplerate = out_format.rate / mpctx->audio_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;
|
2015-10-08 21:08:20 +00:00
|
|
|
mpctx->written_audio += played / (double)out_format.rate;
|
2013-10-29 21:38:29 +00:00
|
|
|
return played;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-10-08 21:08:20 +00:00
|
|
|
static void dump_audio_stats(struct MPContext *mpctx)
|
|
|
|
{
|
|
|
|
if (!mp_msg_test(mpctx->log, MSGL_STATS))
|
|
|
|
return;
|
2015-10-28 22:56:31 +00:00
|
|
|
if (mpctx->audio_status != STATUS_PLAYING || !mpctx->ao || mpctx->paused) {
|
|
|
|
mpctx->audio_stat_start = 0;
|
2015-10-08 21:08:20 +00:00
|
|
|
return;
|
2015-10-28 22:56:31 +00:00
|
|
|
}
|
2015-10-08 21:08:20 +00:00
|
|
|
|
|
|
|
double delay = ao_get_delay(mpctx->ao);
|
|
|
|
if (!mpctx->audio_stat_start) {
|
|
|
|
mpctx->audio_stat_start = mp_time_us();
|
|
|
|
mpctx->written_audio = delay;
|
|
|
|
}
|
|
|
|
double current_audio = mpctx->written_audio - delay;
|
|
|
|
double current_time = (mp_time_us() - mpctx->audio_stat_start) / 1e6;
|
|
|
|
MP_STATS(mpctx, "value %f ao-dev", current_audio - current_time);
|
|
|
|
}
|
|
|
|
|
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);
|
2015-08-10 16:40:16 +00:00
|
|
|
double play_samplerate = out_format.rate / mpctx->audio_speed;
|
2014-03-07 14:24:32 +00:00
|
|
|
|
2015-03-10 14:17:57 +00:00
|
|
|
if (!opts->initial_audio_sync) {
|
2014-07-28 18:40:43 +00:00
|
|
|
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);
|
2016-01-21 21:41:41 +00:00
|
|
|
if (written_pts == MP_NOPTS_VALUE &&
|
|
|
|
!mp_audio_buffer_samples(mpctx->ao_chain->ao_buffer))
|
2014-07-28 18:40:43 +00:00
|
|
|
return false; // no audio read yet
|
|
|
|
|
2016-02-01 21:14:32 +00:00
|
|
|
bool sync_to_video = mpctx->vo_chain && !mpctx->vo_chain->is_coverart &&
|
2015-01-28 18:36:46 +00:00
|
|
|
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
|
2016-01-29 21:43:59 +00:00
|
|
|
if (mpctx->video_pts != MP_NOPTS_VALUE)
|
|
|
|
sync_pts = mpctx->video_pts - opts->audio_delay;
|
2014-07-28 18:40:43 +00:00
|
|
|
} else if (mpctx->hrseek_active) {
|
|
|
|
sync_pts = mpctx->hrseek_pts;
|
2016-08-07 14:00:14 +00:00
|
|
|
} else {
|
|
|
|
// If audio-only is enabled mid-stream during playback, sync accordingly.
|
2016-08-06 15:41:44 +00:00
|
|
|
sync_pts = mpctx->playback_pts;
|
2016-08-07 14:00:14 +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.
|
player: detect audio PTS jumps, make video PTS heuristic less aggressive
This is another attempt at making files with sparse video frames work
better.
The problem is that you generally can't know whether a jump in video
timestamps is just a (very) long video frame, or a timestamp reset. Due
to the existence of files with sparse video frames (new frame only every
few seconds or longer), every heuristic will be arbitrary (in general,
at least).
But we can use the fact that if video is continuous, audio should also
be continuous. Audio discontinuities can be easily detected, and if that
happens, reset some of the playback state.
The way the playback state is reset is rather radical (resets decoders
as well), but it's just better not to cause too much obscure stuff to
happen here. If the A/V sync code were to be rewritten, it should
probably strictly use PTS values (not this strange time_frame/delay
stuff), which would make it much easier to detect such situations and
to react to them.
2016-01-09 19:27:03 +00:00
|
|
|
if (written_pts == MP_NOPTS_VALUE) {
|
2014-07-28 18:40:43 +00:00
|
|
|
MP_WARN(mpctx, "Failed audio resync.\n");
|
|
|
|
mpctx->audio_status = STATUS_FILLING;
|
|
|
|
return true;
|
|
|
|
}
|
player: detect audio PTS jumps, make video PTS heuristic less aggressive
This is another attempt at making files with sparse video frames work
better.
The problem is that you generally can't know whether a jump in video
timestamps is just a (very) long video frame, or a timestamp reset. Due
to the existence of files with sparse video frames (new frame only every
few seconds or longer), every heuristic will be arbitrary (in general,
at least).
But we can use the fact that if video is continuous, audio should also
be continuous. Audio discontinuities can be easily detected, and if that
happens, reset some of the playback state.
The way the playback state is reset is rather radical (resets decoders
as well), but it's just better not to cause too much obscure stuff to
happen here. If the A/V sync code were to be rewritten, it should
probably strictly use PTS values (not this strange time_frame/delay
stuff), which would make it much easier to detect such situations and
to react to them.
2016-01-09 19:27:03 +00:00
|
|
|
ptsdiff = MPCLAMP(ptsdiff, -3600, 3600);
|
2014-07-28 18:40:43 +00:00
|
|
|
|
player: gross hack to improve non-hr seeking with external audio tracks
Relative seeks backwards with external audio tracks does not always work
well: it tends to happen that video seek back further than audio, so
audio will remain silent until the audio's after-seek position is
reached. This happens because we strictly seek both video and audio
demuxer to the approximate desirted target PTS, and then start decoding
from that.
Commit 81358380 removes an older method that was supposed to deal with
this. It was sort of bad, because it could lead to the playback core
freezing by waiting on network.
Ideally, the demuxer layer would probably somehow deal with such seeks,
and do them in a way the audio is seeked after video. Currently this is
infeasible, because the demuxer layer assumes a single demuxer, and
external tracks simply use separate demuxer layers. (MPlayer actually
had a pseudo-demuxer that joined external tracks into a single demuxer,
but this is not flexible enough - and also, the demuxer layer as it
currently exists can't deal with dynamically removing external tracks
either. Maybe some time in the future.)
Instead, add a gross hack, that essentially reseeks the audio if it
detects that it's too far off. The result is actually not too bad,
because we can reuse the mechanism that is used for instant track
switching. This way we can make sure of the right position, without
having to care about certain other issues.
It should be noted that if the audio demuxer is used for other tracks
too, and the demuxer does not support refresh seeking, audio will
probably be off by even a higher amount. But this should be rare.
2016-08-07 14:29:13 +00:00
|
|
|
// Heuristic: if audio is "too far" ahead, and one of them is a separate
|
|
|
|
// track, allow a refresh seek to the correct position to fix it.
|
|
|
|
if (ptsdiff > 0.2 && mpctx->audio_allow_second_chance_seek && sync_to_video) {
|
|
|
|
struct ao_chain *ao_c = mpctx->ao_chain;
|
|
|
|
if (ao_c && ao_c->track && mpctx->vo_chain && mpctx->vo_chain->track &&
|
|
|
|
ao_c->track->demuxer != mpctx->vo_chain->track->demuxer)
|
|
|
|
{
|
|
|
|
struct track *track = ao_c->track;
|
|
|
|
double pts = mpctx->video_pts;
|
|
|
|
if (pts != MP_NOPTS_VALUE)
|
|
|
|
pts += get_track_seek_offset(mpctx, track);
|
|
|
|
// (disable it first to make it take any effect)
|
|
|
|
demuxer_select_track(track->demuxer, track->stream, pts, false);
|
|
|
|
demuxer_select_track(track->demuxer, track->stream, pts, true);
|
|
|
|
reset_audio_state(mpctx);
|
|
|
|
MP_VERBOSE(mpctx, "retrying audio seek\n");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
mpctx->audio_allow_second_chance_seek = false;
|
|
|
|
|
2015-03-10 14:17:57 +00:00
|
|
|
int align = af_format_sample_alignment(out_format.format);
|
2015-11-04 15:47:11 +00:00
|
|
|
*skip = (int)(-ptsdiff * play_samplerate) / align * align;
|
2014-07-28 18:40:43 +00:00
|
|
|
return true;
|
2013-10-29 21:38:29 +00:00
|
|
|
}
|
|
|
|
|
2016-01-21 21:10:15 +00:00
|
|
|
|
2016-08-18 18:38:09 +00:00
|
|
|
static bool copy_output(struct MPContext *mpctx, struct mp_audio_buffer *outbuf,
|
|
|
|
int minsamples, double endpts, bool eof, bool *seteof)
|
2016-01-21 21:10:15 +00:00
|
|
|
{
|
2016-08-18 18:38:09 +00:00
|
|
|
struct af_stream *afs = mpctx->ao_chain->af;
|
|
|
|
|
2016-01-21 21:10:15 +00:00
|
|
|
while (mp_audio_buffer_samples(outbuf) < minsamples) {
|
|
|
|
if (af_output_frame(afs, eof) < 0)
|
|
|
|
return true; // error, stop doing stuff
|
2016-08-18 18:38:09 +00:00
|
|
|
|
|
|
|
int cursamples = mp_audio_buffer_samples(outbuf);
|
|
|
|
int maxsamples = INT_MAX;
|
|
|
|
if (endpts != MP_NOPTS_VALUE) {
|
|
|
|
double rate = afs->output.rate / mpctx->audio_speed;
|
|
|
|
double curpts = written_audio_pts(mpctx);
|
|
|
|
if (curpts != MP_NOPTS_VALUE)
|
|
|
|
maxsamples = (endpts - curpts - mpctx->opts->audio_delay) * rate;
|
|
|
|
}
|
|
|
|
|
2016-01-21 21:10:15 +00:00
|
|
|
struct mp_audio *mpa = af_read_output_frame(afs);
|
|
|
|
if (!mpa)
|
|
|
|
return false; // out of data
|
2016-08-18 18:38:09 +00:00
|
|
|
|
|
|
|
if (cursamples + mpa->samples > maxsamples) {
|
|
|
|
if (cursamples < maxsamples) {
|
|
|
|
struct mp_audio pre = *mpa;
|
|
|
|
pre.samples = maxsamples - cursamples;
|
|
|
|
mp_audio_buffer_append(outbuf, &pre);
|
|
|
|
mp_audio_skip_samples(mpa, pre.samples);
|
|
|
|
}
|
|
|
|
af_unread_output_frame(afs, mpa);
|
|
|
|
*seteof = true;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-01-21 21:10:15 +00:00
|
|
|
mp_audio_buffer_append(outbuf, mpa);
|
|
|
|
talloc_free(mpa);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_new_frame(struct ao_chain *ao_c)
|
|
|
|
{
|
|
|
|
if (ao_c->input_frame)
|
|
|
|
return AD_OK;
|
|
|
|
|
2016-02-05 22:19:56 +00:00
|
|
|
int res = DATA_EOF;
|
|
|
|
if (ao_c->filter_src) {
|
|
|
|
res = lavfi_request_frame_a(ao_c->filter_src, &ao_c->input_frame);
|
|
|
|
} else if (ao_c->audio_src) {
|
2016-01-21 21:10:15 +00:00
|
|
|
audio_work(ao_c->audio_src);
|
|
|
|
res = audio_get_frame(ao_c->audio_src, &ao_c->input_frame);
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (res) {
|
2016-02-01 20:32:01 +00:00
|
|
|
case DATA_OK: return AD_OK;
|
|
|
|
case DATA_WAIT: return AD_WAIT;
|
2016-02-05 22:19:56 +00:00
|
|
|
case DATA_AGAIN: return AD_NO_PROGRESS;
|
2016-02-01 20:32:01 +00:00
|
|
|
case DATA_EOF: return AD_EOF;
|
2016-01-21 21:10:15 +00:00
|
|
|
default: abort();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Try to get at least minsamples decoded+filtered samples in outbuf
|
|
|
|
* (total length including possible existing data).
|
|
|
|
* Return 0 on success, or negative AD_* error code.
|
|
|
|
* In the former case outbuf has at least minsamples buffered on return.
|
|
|
|
* In case of EOF/error it might or might not be. */
|
2016-08-18 18:38:09 +00:00
|
|
|
static int filter_audio(struct MPContext *mpctx, struct mp_audio_buffer *outbuf,
|
2016-01-21 21:10:15 +00:00
|
|
|
int minsamples)
|
|
|
|
{
|
2016-08-18 18:38:09 +00:00
|
|
|
struct ao_chain *ao_c = mpctx->ao_chain;
|
2016-01-21 21:10:15 +00:00
|
|
|
struct af_stream *afs = ao_c->af;
|
|
|
|
if (afs->initialized < 1)
|
|
|
|
return AD_ERR;
|
|
|
|
|
|
|
|
MP_STATS(ao_c, "start audio");
|
|
|
|
|
2016-08-18 18:38:09 +00:00
|
|
|
double endpts = get_play_end_pts(mpctx);
|
|
|
|
|
|
|
|
bool eof = false;
|
2016-01-21 21:10:15 +00:00
|
|
|
int res;
|
|
|
|
while (1) {
|
|
|
|
res = 0;
|
|
|
|
|
2016-08-18 18:38:09 +00:00
|
|
|
if (copy_output(mpctx, outbuf, minsamples, endpts, false, &eof))
|
2016-01-21 21:10:15 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
res = decode_new_frame(ao_c);
|
2017-01-08 11:50:26 +00:00
|
|
|
if (res == AD_NO_PROGRESS || res == AD_WAIT)
|
2016-02-05 22:19:56 +00:00
|
|
|
break;
|
2016-01-21 21:10:15 +00:00
|
|
|
if (res < 0) {
|
|
|
|
// drain filters first (especially for true EOF case)
|
2016-08-18 18:38:09 +00:00
|
|
|
copy_output(mpctx, outbuf, minsamples, endpts, true, &eof);
|
2016-01-21 21:10:15 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// On format change, make sure to drain the filter chain.
|
|
|
|
if (!mp_audio_config_equals(&afs->input, ao_c->input_frame)) {
|
2016-08-18 18:38:09 +00:00
|
|
|
copy_output(mpctx, outbuf, minsamples, endpts, true, &eof);
|
2016-01-21 21:10:15 +00:00
|
|
|
res = AD_NEW_FMT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct mp_audio *mpa = ao_c->input_frame;
|
|
|
|
ao_c->input_frame = NULL;
|
2016-01-29 21:44:20 +00:00
|
|
|
if (mpa->pts == MP_NOPTS_VALUE) {
|
|
|
|
ao_c->pts = MP_NOPTS_VALUE;
|
|
|
|
} else {
|
|
|
|
// Attempt to detect jumps in PTS. Even for the lowest sample rates
|
|
|
|
// and with worst container rounded timestamp, this should be a
|
|
|
|
// margin more than enough.
|
2016-10-20 18:11:56 +00:00
|
|
|
double desync = mpa->pts - ao_c->pts;
|
|
|
|
if (ao_c->pts != MP_NOPTS_VALUE && fabs(desync) > 0.1) {
|
2016-01-29 21:44:20 +00:00
|
|
|
MP_WARN(ao_c, "Invalid audio PTS: %f -> %f\n",
|
|
|
|
ao_c->pts, mpa->pts);
|
2016-01-31 21:10:11 +00:00
|
|
|
if (desync >= 5)
|
|
|
|
ao_c->pts_reset = true;
|
2016-01-29 21:44:20 +00:00
|
|
|
}
|
|
|
|
ao_c->pts = mpa->pts + mpa->samples / (double)mpa->rate;
|
|
|
|
}
|
2016-01-21 21:10:15 +00:00
|
|
|
if (af_filter_frame(afs, mpa) < 0)
|
|
|
|
return AD_ERR;
|
|
|
|
}
|
|
|
|
|
2016-08-18 18:38:09 +00:00
|
|
|
if (res == 0 && mp_audio_buffer_samples(outbuf) < minsamples && eof)
|
|
|
|
res = AD_EOF;
|
|
|
|
|
2016-01-21 21:10:15 +00:00
|
|
|
MP_STATS(ao_c, "end audio");
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2016-10-05 14:42:43 +00:00
|
|
|
void reload_audio_output(struct MPContext *mpctx)
|
|
|
|
{
|
|
|
|
if (!mpctx->ao)
|
|
|
|
return;
|
|
|
|
|
|
|
|
ao_reset(mpctx->ao);
|
|
|
|
uninit_audio_out(mpctx);
|
|
|
|
reinit_audio_filters(mpctx); // mostly to issue refresh seek
|
|
|
|
|
|
|
|
// Whether we can use spdif might have changed. If we failed to use spdif
|
|
|
|
// in the previous initialization, try it with spdif again (we'll fallback
|
|
|
|
// to PCM again if necessary).
|
|
|
|
struct ao_chain *ao_c = mpctx->ao_chain;
|
|
|
|
if (ao_c) {
|
|
|
|
struct dec_audio *d_audio = ao_c->audio_src;
|
|
|
|
if (d_audio && ao_c->spdif_failed) {
|
|
|
|
ao_c->spdif_passthrough = true;
|
|
|
|
ao_c->spdif_failed = false;
|
|
|
|
d_audio->try_spdif = true;
|
|
|
|
ao_c->af->initialized = 0;
|
|
|
|
if (!audio_init_best_codec(d_audio)) {
|
|
|
|
MP_ERR(mpctx, "Error reinitializing audio.\n");
|
|
|
|
error_on_track(mpctx, ao_c->track);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
mp_wakeup_core(mpctx);
|
|
|
|
}
|
|
|
|
|
2016-02-27 19:02:51 +00:00
|
|
|
void fill_audio_out_buffers(struct MPContext *mpctx)
|
2013-10-29 21:38:29 +00:00
|
|
|
{
|
|
|
|
struct MPOpts *opts = mpctx->opts;
|
2016-08-24 10:14:48 +00:00
|
|
|
bool was_eof = mpctx->audio_status == STATUS_EOF;
|
2013-10-29 21:38:29 +00:00
|
|
|
|
2015-10-08 21:08:20 +00:00
|
|
|
dump_audio_stats(mpctx);
|
|
|
|
|
2016-10-05 14:42:43 +00:00
|
|
|
if (mpctx->ao && ao_query_and_reset_events(mpctx->ao, AO_EVENT_RELOAD))
|
|
|
|
reload_audio_output(mpctx);
|
2014-11-09 08:58:44 +00:00
|
|
|
|
2016-10-05 14:42:43 +00:00
|
|
|
struct ao_chain *ao_c = mpctx->ao_chain;
|
2016-01-21 21:10:15 +00:00
|
|
|
if (!ao_c)
|
2014-07-30 21:24:08 +00:00
|
|
|
return;
|
2013-11-23 20:22:17 +00:00
|
|
|
|
2016-01-21 21:10:15 +00:00
|
|
|
if (ao_c->af->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.
|
2016-01-21 21:10:15 +00:00
|
|
|
int r = decode_new_frame(mpctx->ao_chain);
|
2014-07-28 18:40:43 +00:00
|
|
|
if (r == AD_WAIT)
|
2014-07-29 22:24:57 +00:00
|
|
|
return; // continue later when new data is available
|
2016-02-06 17:33:31 +00:00
|
|
|
if (r == AD_EOF) {
|
|
|
|
mpctx->audio_status = STATUS_EOF;
|
|
|
|
return;
|
|
|
|
}
|
2016-01-29 21:44:35 +00:00
|
|
|
reinit_audio_filters_and_output(mpctx);
|
2016-09-16 12:24:15 +00:00
|
|
|
mp_wakeup_core(mpctx);
|
2014-07-29 22:24:57 +00:00
|
|
|
return; // try again next iteration
|
2013-10-29 21:38:29 +00:00
|
|
|
}
|
|
|
|
|
2016-08-09 14:26:44 +00:00
|
|
|
if (ao_c->ao_resume_time > mp_time_sec()) {
|
|
|
|
double remaining = ao_c->ao_resume_time - mp_time_sec();
|
2016-09-16 12:24:15 +00:00
|
|
|
mp_set_timeout(mpctx, remaining);
|
2016-08-09 14:26:44 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-01-29 21:44:20 +00:00
|
|
|
if (mpctx->vo_chain && ao_c->pts_reset) {
|
player: detect audio PTS jumps, make video PTS heuristic less aggressive
This is another attempt at making files with sparse video frames work
better.
The problem is that you generally can't know whether a jump in video
timestamps is just a (very) long video frame, or a timestamp reset. Due
to the existence of files with sparse video frames (new frame only every
few seconds or longer), every heuristic will be arbitrary (in general,
at least).
But we can use the fact that if video is continuous, audio should also
be continuous. Audio discontinuities can be easily detected, and if that
happens, reset some of the playback state.
The way the playback state is reset is rather radical (resets decoders
as well), but it's just better not to cause too much obscure stuff to
happen here. If the A/V sync code were to be rewritten, it should
probably strictly use PTS values (not this strange time_frame/delay
stuff), which would make it much easier to detect such situations and
to react to them.
2016-01-09 19:27:03 +00:00
|
|
|
MP_VERBOSE(mpctx, "Reset playback due to audio timestamp reset.\n");
|
|
|
|
reset_playback_state(mpctx);
|
2016-09-16 12:24:15 +00:00
|
|
|
mp_wakeup_core(mpctx);
|
player: detect audio PTS jumps, make video PTS heuristic less aggressive
This is another attempt at making files with sparse video frames work
better.
The problem is that you generally can't know whether a jump in video
timestamps is just a (very) long video frame, or a timestamp reset. Due
to the existence of files with sparse video frames (new frame only every
few seconds or longer), every heuristic will be arbitrary (in general,
at least).
But we can use the fact that if video is continuous, audio should also
be continuous. Audio discontinuities can be easily detected, and if that
happens, reset some of the playback state.
The way the playback state is reset is rather radical (resets decoders
as well), but it's just better not to cause too much obscure stuff to
happen here. If the A/V sync code were to be rewritten, it should
probably strictly use PTS values (not this strange time_frame/delay
stuff), which would make it much easier to detect such situations and
to react to them.
2016-01-09 19:27:03 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-08-15 21:52:42 +00:00
|
|
|
struct mp_audio out_format = {0};
|
|
|
|
ao_get_format(mpctx->ao, &out_format);
|
2015-08-10 16:40:16 +00:00
|
|
|
double play_samplerate = out_format.rate / mpctx->audio_speed;
|
2015-11-04 15:47:11 +00:00
|
|
|
int align = af_format_sample_alignment(out_format.format);
|
2014-08-15 21:52:42 +00:00
|
|
|
|
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
|
|
|
|
2015-10-27 19:56:46 +00:00
|
|
|
int skip_duplicate = 0; // >0: skip, <0: duplicate
|
2015-11-03 19:29:25 +00:00
|
|
|
double drop_limit =
|
|
|
|
(opts->sync_max_audio_change + opts->sync_max_video_change) / 100;
|
2015-10-27 19:56:46 +00:00
|
|
|
if (mpctx->display_sync_active && opts->video_sync == VS_DISP_ADROP &&
|
|
|
|
fabs(mpctx->last_av_difference) >= opts->sync_audio_drop_size &&
|
2015-11-03 19:29:25 +00:00
|
|
|
mpctx->audio_drop_throttle < drop_limit &&
|
2015-10-27 19:56:46 +00:00
|
|
|
mpctx->audio_status == STATUS_PLAYING)
|
|
|
|
{
|
|
|
|
int samples = ceil(opts->sync_audio_drop_size * play_samplerate);
|
|
|
|
samples = (samples + align / 2) / align * align;
|
|
|
|
|
|
|
|
skip_duplicate = mpctx->last_av_difference >= 0 ? -samples : samples;
|
|
|
|
|
2015-10-28 22:50:59 +00:00
|
|
|
playsize = MPMAX(playsize, samples);
|
2015-11-03 19:29:25 +00:00
|
|
|
|
|
|
|
mpctx->audio_drop_throttle += 1 - drop_limit - samples / play_samplerate;
|
2015-10-27 19:56:46 +00:00
|
|
|
}
|
|
|
|
|
2015-11-04 15:47:11 +00:00
|
|
|
playsize = playsize / align * align;
|
|
|
|
|
2016-08-18 18:38:09 +00:00
|
|
|
int status = mpctx->audio_status >= STATUS_DRAINING ? AD_EOF : AD_OK;
|
2015-05-19 21:23:17 +00:00
|
|
|
bool working = false;
|
2016-01-21 21:41:41 +00:00
|
|
|
if (playsize > mp_audio_buffer_samples(ao_c->ao_buffer)) {
|
2016-08-18 18:38:09 +00:00
|
|
|
status = filter_audio(mpctx, ao_c->ao_buffer, playsize);
|
2014-07-28 18:40:43 +00:00
|
|
|
if (status == AD_WAIT)
|
2014-07-29 22:24:57 +00:00
|
|
|
return;
|
2016-02-05 22:19:56 +00:00
|
|
|
if (status == AD_NO_PROGRESS) {
|
2016-09-16 12:24:15 +00:00
|
|
|
mp_wakeup_core(mpctx);
|
2016-02-05 22:19:56 +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);
|
2016-01-29 21:44:35 +00:00
|
|
|
reinit_audio_filters_and_output(mpctx);
|
2016-09-16 12:24:15 +00:00
|
|
|
mp_wakeup_core(mpctx);
|
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)
|
2016-09-16 12:24:15 +00:00
|
|
|
mp_wakeup_core(mpctx);
|
2015-05-19 21:23:17 +00:00
|
|
|
working = true;
|
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.
|
2016-10-02 11:47:19 +00:00
|
|
|
if (mpctx->audio_status >= STATUS_DRAINING &&
|
|
|
|
mp_audio_buffer_samples(ao_c->ao_buffer) > 0)
|
|
|
|
{
|
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) {
|
2016-01-21 21:41:41 +00:00
|
|
|
int max = mp_audio_buffer_samples(ao_c->ao_buffer);
|
|
|
|
mp_audio_buffer_skip(ao_c->ao_buffer, MPMIN(skip, max));
|
2014-07-28 18:40:43 +00:00
|
|
|
// If something is left, we definitely reached the target time.
|
|
|
|
end_sync |= sync_known && skip < max;
|
2016-01-31 21:02:02 +00:00
|
|
|
working |= skip > 0;
|
2014-07-28 18:40:43 +00:00
|
|
|
} 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
|
|
|
}
|
2016-01-21 21:41:41 +00:00
|
|
|
mp_audio_buffer_prepend_silence(ao_c->ao_buffer, -skip);
|
2014-07-28 18:40:43 +00:00
|
|
|
end_sync = true;
|
|
|
|
}
|
|
|
|
|
2015-10-27 19:56:46 +00:00
|
|
|
if (skip_duplicate) {
|
2016-01-21 21:41:41 +00:00
|
|
|
int max = mp_audio_buffer_samples(ao_c->ao_buffer);
|
2015-10-27 19:56:46 +00:00
|
|
|
if (abs(skip_duplicate) > max)
|
|
|
|
skip_duplicate = skip_duplicate >= 0 ? max : -max;
|
|
|
|
mpctx->last_av_difference += skip_duplicate / play_samplerate;
|
|
|
|
if (skip_duplicate >= 0) {
|
2016-01-21 21:41:41 +00:00
|
|
|
mp_audio_buffer_skip(ao_c->ao_buffer, skip_duplicate);
|
2015-10-27 19:56:46 +00:00
|
|
|
MP_STATS(mpctx, "drop-audio");
|
|
|
|
} else {
|
2016-01-21 21:41:41 +00:00
|
|
|
mp_audio_buffer_duplicate(ao_c->ao_buffer, -skip_duplicate);
|
2015-10-27 19:56:46 +00:00
|
|
|
MP_STATS(mpctx, "duplicate-audio");
|
|
|
|
}
|
|
|
|
MP_VERBOSE(mpctx, "audio skip_duplicate=%d\n", skip_duplicate);
|
|
|
|
}
|
|
|
|
|
2014-07-28 18:40:43 +00:00
|
|
|
if (mpctx->audio_status == STATUS_SYNCING) {
|
|
|
|
if (end_sync)
|
|
|
|
mpctx->audio_status = STATUS_FILLING;
|
2016-01-21 21:41:41 +00:00
|
|
|
if (status != AD_OK && !mp_audio_buffer_samples(ao_c->ao_buffer))
|
2014-07-30 20:29:24 +00:00
|
|
|
mpctx->audio_status = STATUS_EOF;
|
2015-08-23 19:41:09 +00:00
|
|
|
if (working || end_sync)
|
2016-09-16 12:24:15 +00:00
|
|
|
mp_wakeup_core(mpctx);
|
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);
|
|
|
|
|
2016-04-20 11:05:29 +00:00
|
|
|
// We already have as much data as the audio device wants, and can start
|
|
|
|
// writing it any time.
|
|
|
|
if (mpctx->audio_status == STATUS_FILLING)
|
|
|
|
mpctx->audio_status = STATUS_READY;
|
|
|
|
|
2014-07-28 18:40:43 +00:00
|
|
|
// Even if we're done decoding and syncing, let video start first - this is
|
|
|
|
// required, because sending audio to the AO already starts playback.
|
2016-04-20 11:05:29 +00:00
|
|
|
if (mpctx->audio_status == STATUS_READY) {
|
|
|
|
if (mpctx->vo_chain && !mpctx->vo_chain->is_coverart &&
|
|
|
|
mpctx->video_status <= STATUS_READY)
|
|
|
|
return;
|
|
|
|
MP_VERBOSE(mpctx, "starting audio playback\n");
|
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;
|
|
|
|
|
2016-01-21 21:41:41 +00:00
|
|
|
if (playsize > mp_audio_buffer_samples(ao_c->ao_buffer)) {
|
|
|
|
playsize = mp_audio_buffer_samples(ao_c->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
|
|
|
|
2013-11-10 22:38:18 +00:00
|
|
|
struct mp_audio data;
|
2016-01-21 21:41:41 +00:00
|
|
|
mp_audio_buffer_peek(ao_c->ao_buffer, &data);
|
2015-11-04 15:47:11 +00:00
|
|
|
if (audio_eof || data.samples >= align)
|
|
|
|
data.samples = data.samples / align * align;
|
2015-08-03 15:02:06 +00:00
|
|
|
data.samples = MPMIN(data.samples, mpctx->paused ? 0 : playsize);
|
2015-07-24 15:27:40 +00:00
|
|
|
int played = write_to_ao(mpctx, &data, playflags);
|
2014-02-09 15:21:17 +00:00
|
|
|
assert(played >= 0 && played <= data.samples);
|
2016-01-21 21:41:41 +00:00
|
|
|
mp_audio_buffer_skip(ao_c->ao_buffer, played);
|
2013-10-29 21:38:29 +00:00
|
|
|
|
2015-11-04 09:57:07 +00:00
|
|
|
mpctx->audio_drop_throttle =
|
|
|
|
MPMAX(0, mpctx->audio_drop_throttle - played / play_samplerate);
|
2015-11-03 19:29:25 +00:00
|
|
|
|
2015-10-08 21:08:20 +00:00
|
|
|
dump_audio_stats(mpctx);
|
|
|
|
|
2014-07-28 18:40:43 +00:00
|
|
|
mpctx->audio_status = STATUS_PLAYING;
|
2015-08-03 15:02:06 +00:00
|
|
|
if (audio_eof && !playsize) {
|
2014-07-28 18:40:43 +00:00
|
|
|
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.
|
2016-08-24 10:14:48 +00:00
|
|
|
if (ao_eof_reached(mpctx->ao) || opts->gapless_audio) {
|
2014-07-28 18:40:43 +00:00
|
|
|
mpctx->audio_status = STATUS_EOF;
|
2017-03-14 14:55:42 +00:00
|
|
|
if (!was_eof) {
|
|
|
|
MP_VERBOSE(mpctx, "audio EOF reached\n");
|
2016-09-16 12:24:15 +00:00
|
|
|
mp_wakeup_core(mpctx);
|
2017-03-14 14:55:42 +00:00
|
|
|
}
|
2016-08-24 10:14:48 +00:00
|
|
|
}
|
2014-07-28 18:40:43 +00:00
|
|
|
}
|
2013-10-29 21:38:29 +00:00
|
|
|
}
|
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);
|
|
|
|
}
|