Desde o Audacious 3.6, o encadeamento de playback é completamente assíncrono; isso é, a thread principal nunca bloqueia a espera para o segmento de reprodução para processar um comando play (), seek () ou stop (). Como resultado, o encadeamento de reprodução pode atrasar por trás do tópico principal / playlist, e a música "atual" da perspectiva do segmento de reprodução pode não ser o mesmo que a música "atual" da perspectiva do segmento principal / playlist. Portanto, alguns cuidados são necessários para garantir que as informações geradas no encadeamento de reprodução não sejam aplicadas à música errada. Para este fim, números de série separados são mantidos por cada thread e comparados quando a informação ultrapassa os limites das threads; se os números séries não coincidem, a informação é geralmente descartada. Note que este arquivo e o playlist.cc possuem seu próprio mutex. O playlist.cc é conceitualmente o mutex "externo" e deve ser bloqueado primeiro (em situações que ambos precisam ser bloqueados) para evitar o impasse.
/*
playback.cc
Copyright 2009-2014 John Lindgren
*/
#include "drct.h"
#include "internal.h"
#include
#include
#include "audstrings.h"
#include "hook.h"
#include "i18n.h"
#include "interface.h"
#include "mainloop.h"
#include "output.h"
#include "playlist-internal.h"
#include "plugin.h"
#include "plugins.h"
#include "plugins-internal.h"
#include "runtime.h"
struct PlaybackState {
bool playing = false;
bool thread_running = false;
int control_serial = 0;
int playback_serial = 0;
};
struct PlaybackControl {
bool paused = false;
int seek = -1;
int repeat_a = -1;
int repeat_b = -1;
};
struct PlaybackInfo {
// set by playback_set_info
int entry = -1;
Tuple tuple;
String title;
// set by playback thread
String filename;
int length = -1;
int time_offset = 0;
int stop_time = -1;
ReplayGainInfo gain {};
bool gain_valid = false;
int bitrate = 0;
int samplerate = 0;
int channels = 0;
bool ready = false;
bool ended = false;
bool error = false;
String error_s;
};
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
static PlaybackState pb_state;
static PlaybackControl pb_control;
static PlaybackInfo pb_info;
static QueuedFunc end_queue;
static bool song_finished = false;
static int failed_entries = 0;
static void lock ()
{
pthread_mutex_lock (& mutex);
}
static void unlock ()
{
pthread_mutex_unlock (& mutex);
}
static bool lock_if (bool (* test) ())
{
lock ();
if (test ())
return true;
unlock ();
return false;
}
// verifica se o encadeamento da reprodução não está atrasado
static bool in_sync ()
{
return pb_state.playing && pb_state.control_serial == pb_state.playback_serial;
}
// verifica se o encadeamento de reprodução não está atrasado e se a reprodução está "pronta"
static bool is_ready ()
{
return in_sync () && pb_info.ready;
}
// chamado por playback_entry_set_tuple () para garantir que a tupla ainda se aplique
// para a música atual da perspectiva do segmento principal / playlist; a
// check é necessário porque playback_entry_set_tuple () é ele mesmo chamado de
// o segmento de reprodução
bool playback_check_serial (int serial)
{
lock ();
bool okay = (pb_state.playing && pb_state.control_serial == serial);
unlock ();
return okay;
}
// chamado da lista de reprodução para atualizar a tupla da música atual
void playback_set_info (int entry, Tuple && tuple)
{
// não faz nada se o segmento de reprodução estiver atrasado;
// Nesse caso, playback_set_info () será chamado novamente de qualquer maneira
if (! lock_if (in_sync))
return;
if (tuple.valid () && tuple != pb_info.tuple)
{
pb_info.tuple = std::move (tuple);
// não chame "tuple change" antes de "reprodução pronta"
if (is_ready ())
{
event_queue ("tuple change", nullptr);
output_set_tuple (pb_info.tuple);
}
}
String title = pb_info.tuple.get_str (Tuple::FormattedTitle);
if (entry != pb_info.entry || title != pb_info.title)
{
pb_info.entry = entry;
pb_info.title = title;
// não chame "title change" antes de "playback ready"
if (is_ready ())
event_queue ("title change", nullptr);
}
unlock ();
}
// limpeza comum para playback_play () e playback_stop ()
static void playback_cleanup_locked ()
{
pb_state.playing = false;
pb_control = PlaybackControl ();
// descarte o buffer de áudio se a música não terminar sozinha
if (! song_finished)
output_flush (0);
// limpeza alternada
end_queue.stop ();
song_finished = false;
event_queue_cancel ("playback ready");
event_queue_cancel ("playback pause");
event_queue_cancel ("playback unpause");
event_queue_cancel ("playback seek");
event_queue_cancel ("info change");
event_queue_cancel ("title change");
event_queue_cancel ("tuple change");
aud_set_bool (nullptr, "stop_after_current_song", false);
}
// main thread: interrompe a reprodução quando não é mais necessário tocar músicas void playback_stop (bool exiting)
{
if (! pb_state.playing && ! exiting)
return;
lock ();
if (pb_state.playing)
playback_cleanup_locked ();
if (pb_state.thread_running)
{
// se sair descarte o áudio do buffer
if (exiting)
output_flush (0, true);
// thread de reprodução de sinal para drenar o buffer de áudio
pb_state.control_serial ++;
pthread_cond_broadcast (& cond);
// aguarde até que o encadeamento de reprodução termine se sair
while (exiting && pb_state.thread_running)
pthread_cond_wait (& cond, & mutex);
}
unlock ();
// limpeza alternada
failed_entries = 0;
}
// chamada do loop de evento de nível superior após a reprodução terminar
static void end_cb (void *)
{
song_finished = true;
hook_call ("playback end", nullptr);
PlaylistEx playlist = Playlist::playing_playlist ();
auto do_stop = [playlist] ()
{
aud_drct_stop ();
playlist.set_position (playlist.get_position ());
};
auto do_next = [playlist] ()
{
if (! playlist.next_song (aud_get_bool (nullptr, "repeat")))
{
playlist.set_position (-1);
hook_call ("playlist end reached", nullptr);
}
};
if (aud_get_bool (nullptr, "no_playlist_advance"))
{
// assumimos aqui que a repetição não está habilitada;
// repetições de uma única música são tratadas em run_playback ()
do_stop ();
}
else if (aud_get_bool (nullptr, "stop_after_current_song"))
{
do_stop ();
do_next ();
}
else
{
// se 10 músicas em sequência falharem ou se falhou a playlist inteira
// (para playlists com menos de 10 músicas) falhou, pare de tentar
if (failed_entries < aud::min (playlist.n_entries (), 10))
do_next ();
else
do_stop ();
}
}
// helper, pode ser chamado a partir do thread principal ou de reprodução
static void request_seek_locked (int time)
{
// configurar o comando "seek", esteja pronto ou não;
//se não estiver pronto, entrará em vigor após open_audio ()
pb_control.seek = aud::max (0, time);
// trigger seek imediatamente se estiver pronto
if (is_ready () && pb_info.length > 0)
{
output_flush (aud::clamp (time, 0, pb_info.length));
event_queue ("playback seek", nullptr);
}
}
// ajudante de segmento de reprodução de thread
static void run_playback ()
{
// devido ao pedido de mutex, não podemos chamar a playlist enquanto estiver bloqueada
DecodeInfo dec = playback_entry_read (pb_state.playback_serial);
if (! lock_if (in_sync))
return;
// para uma entrada de cuesheet, determine o nome do arquivo de origem
pb_info.filename = pb_info.tuple.get_str (Tuple::AudioFile);
if (! pb_info.filename)
pb_info.filename = std::move (dec.filename);
// verifique se possui todos os dados necessários
if (! pb_info.filename || ! pb_info.tuple.valid () || ! dec.ip ||
(! dec.ip->input_info.keys[InputKey::Scheme] && ! dec.file))
{
pb_info.error = true;
pb_info.error_s = std::move (dec.error);
unlock ();
return;
}
// Obter vários outros bits de informação da tupla
pb_info.length = pb_info.tuple.get_int (Tuple::Length);
pb_info.time_offset = aud::max (0, pb_info.tuple.get_int (Tuple::StartTime));
pb_info.stop_time = aud::max (-1, pb_info.tuple.get_int (Tuple::EndTime) - pb_info.time_offset);
pb_info.gain = pb_info.tuple.get_replay_gain ();
pb_info.gain_valid = pb_info.tuple.has_replay_gain ();
// força inicial busca se estes estão tocando uma faixa segmentada
if (pb_info.time_offset > 0 && pb_control.seek < 0)
pb_control.seek = 0;
unlock ();
while (1)
{
// // forçar a busca inicial se estivermos jogando um controle segmentado fora do controle para inserir o plugin
if (! dec.ip->play (pb_info.filename, dec.file))
pb_info.error = true;
// close audio (não abra se este estiver fechado)
output_close_audio ();
if (pb_info.error || pb_info.length <= 0)
break;
if (! lock_if (in_sync))
break;
// verifique se o audio precisa ser repetido
pb_info.ended = (pb_control.repeat_a < 0 && ! (aud_get_bool (nullptr,
"repeat") && aud_get_bool (nullptr, "no_playlist_advance")));
if (! pb_info.ended)
request_seek_locked (pb_control.repeat_a);
unlock ();
if (pb_info.ended)
break;
// retorne o ponteiro do arquivo para repetir
if (! open_input_file (pb_info.filename, "r", dec.ip, dec.file, & pb_info.error_s))
{
pb_info.error = true;
break;
}
}
}
// ajudante da thread de reprodução
static void finish_playback_locked ()
{
// registrar qualquer erro de execução ocorrido
if (pb_info.error)
{
failed_entries ++;
if (pb_info.error_s)
aud_ui_show_error (str_printf (_("Error playing %s:\n%s"),
(const char *) pb_info.filename, (const char *) pb_info.error_s));
else
AUDERR ("Playback finished with error.\n");
}
else
failed_entries = 0;
// queue chama função para iniciar a próxima música (ou realizar limpeza)
end_queue.queue (end_cb, nullptr);
}
// thread de reprodução
static void * playback_thread (void *)
{
lock ();
while (1)
{
// aguardando por um comando
while (pb_state.control_serial == pb_state.playback_serial)
pthread_cond_wait (& cond, & mutex);
// busque o comando ("play" ou "drain")
bool play = pb_state.playing;
// atualiza o número série da thread de execução
pb_state.playback_serial = pb_state.control_serial;
unlock ();
if (play)
run_playback ();
else
output_drain ();
lock ();
if (play)
{
// não reportar erros ou enfileirar a próxima música se outro comando estiver pendente
if (in_sync ())
finish_playback_locked ();
pb_info = PlaybackInfo ();
}
else
{
// sair se não tiver recebido um novo comando depois da drenagem
if (pb_state.control_serial == pb_state.playback_serial)
break;
}
}
// sinalize a thread principal que estará saindo
pb_state.thread_running = false;
pthread_cond_broadcast (& cond);
unlock ();
return nullptr;
}
// main thread: iniciando a reprodução de uma nova música
void playback_play (int seek_time, bool pause)
{
lock ();
if (pb_state.playing)
playback_cleanup_locked ();
// ativando o comando "play"
pb_state.playing = true;
pb_state.control_serial ++;
pb_control.paused = pause;
pb_control.seek = (seek_time > 0) ? seek_time : -1;
// inicia thread de execução (ou sinalize se já estiver rodando)
if (pb_state.thread_running)
pthread_cond_broadcast (& cond);
else
{
pthread_t thread;
pthread_create (& thread, nullptr, playback_thread, nullptr);
pthread_detach (thread);
pb_state.thread_running = true;
}
unlock ();
}
// main thread
EXPORT void aud_drct_pause ()
{
if (! pb_state.playing)
return;
lock ();
// ativando o comando "pause" esteja pronto ou não;
// se não estiver pronto, este entrará em vigor após open_audio()
bool pause = ! pb_control.paused;
pb_control.paused = pause;
// aplique pause imediatamente se estiver executando
if (is_ready ())
output_pause (pause);
event_queue (pause ? "playback pause" : "playback unpause", nullptr);
unlock ();
}
// main thread
EXPORT void aud_drct_seek (int time)
{
if (! pb_state.playing)
return;
lock ();
request_seek_locked (time);
unlock ();
}
EXPORT void InputPlugin::open_audio (int format, int rate, int channels)
{
// não abra o áudio se a thread de execução estiver atrasada
if (! lock_if (in_sync))
return;
if (! output_open_audio (pb_info.filename, pb_info.tuple, format, rate,
channels, aud::max (0, pb_control.seek)))
{
pb_info.error = true;
pb_info.error_s = String (_("Invalid audio format"));
unlock ();
return;
}
if (pb_info.gain_valid)
output_set_replay_gain (pb_info.gain);
if (pb_control.paused)
output_pause (true);
pb_info.samplerate = rate;
pb_info.channels = channels;
if (pb_info.ready)
event_queue ("info change", nullptr);
else
event_queue ("playback ready", nullptr);
pb_info.ready = true;
unlock ();
}
EXPORT void InputPlugin::set_replay_gain (const ReplayGainInfo & gain)
{
lock ();
pb_info.gain = gain;
pb_info.gain_valid = true;
if (is_ready ())
output_set_replay_gain (gain);
unlock ();
}
EXPORT void InputPlugin::write_audio (const void * data, int length)
{
if (! lock_if (in_sync))
return;
// buscar configuração A-B
int a = pb_control.repeat_a;
int b = pb_control.repeat_b;
unlock ();
// estes estarão prontos para chamar output_write_audio() mesmo que não estiver mais em sincronia,
// já que retornará imediatamente se output_flush () tiver sido chamado
int stop_time = (b >= 0) ? b : pb_info.stop_time;
if (output_write_audio (data, length, stop_time))
return;
if (! lock_if (in_sync))
return;
// se estiverem em sincronia, então ocorreu uma das seguintes situações:
// 1. output_flush() foi chamado devido a um pedido de busca
// 2. nós alcançamos o ponto de repetição B
// 3. nós chegamos ao final de um segmento
if (pb_control.seek < 0)
{
if (b >= 0)
request_seek_locked (a);
else
pb_info.ended = true;
}
unlock ();
}
EXPORT Tuple InputPlugin::get_playback_tuple ()
{
lock ();
Tuple tuple = pb_info.tuple.ref ();
unlock ();
// tuplas passadas de plugins de entrada não possuem campos de fallback
// gerado; para consistência, as tuplas devolvidas não devem ser passadas
tuple.delete_fallbacks ();
return tuple;
}
EXPORT void InputPlugin::set_playback_tuple (Tuple && tuple)
{
// devido à ordenação por mutex, não podemos chamar a playlist enquanto estiver bloqueada;
// em vez disso, playback_entry_set_tuple () chama de volta para o primeiro
// playback_check_serial () e depois playback_set_info ()
playback_entry_set_tuple (pb_state.playback_serial, std::move (tuple));
}
EXPORT void InputPlugin::set_stream_bitrate (int bitrate)
{
lock ();
pb_info.bitrate = bitrate;
if (is_ready ())
event_queue ("info change", nullptr);
unlock ();
}
EXPORT bool InputPlugin::check_stop ()
{
lock ();
bool stop = ! is_ready () || pb_info.ended || pb_info.error;
unlock ();
return stop;
}
EXPORT int InputPlugin::check_seek ()
{
lock ();
int seek = -1;
if (is_ready () && pb_control.seek >= 0 && pb_info.length > 0)
{
seek = pb_info.time_offset + aud::min (pb_control.seek, pb_info.length);
pb_control.seek = -1;
output_resume ();
}
unlock ();
return seek;
}
// thread de proteção
EXPORT bool aud_drct_get_playing ()
{
lock ();
bool playing = pb_state.playing;
unlock ();
return playing;
}
// thread de proteção
EXPORT bool aud_drct_get_ready ()
{
lock ();
bool ready = is_ready ();
unlock ();
return ready;
}
// thread de proteção
EXPORT bool aud_drct_get_paused ()
{
lock ();
bool paused = pb_control.paused;
unlock ();
return paused;
}
// thread de proteção
EXPORT String aud_drct_get_title ()
{
if (! lock_if (is_ready))
return String ();
String title = pb_info.title;
int entry = pb_info.entry;
int length = pb_info.length;
unlock ();
StringBuf prefix = aud_get_bool (nullptr, "show_numbers_in_pl") ?
str_printf ("%d. ", 1 + entry) : StringBuf (0);
StringBuf time = (length > 0) ? str_format_time (length) : StringBuf ();
StringBuf suffix = time ? str_concat ({" (", time, ")"}) : StringBuf (0);
return String (str_concat ({prefix, title, suffix}));
}
// thread de proteção
EXPORT Tuple aud_drct_get_tuple ()
{
lock ();
Tuple tuple = is_ready () ? pb_info.tuple.ref () : Tuple ();
unlock ();
return tuple;
}
// thread de proteção
EXPORT void aud_drct_get_info (int & bitrate, int & samplerate, int & channels)
{
lock ();
bool ready = is_ready ();
bitrate = ready ? pb_info.bitrate : 0;
samplerate = ready ? pb_info.samplerate : 0;
channels = ready ? pb_info.channels : 0;
unlock ();
}
// thread de proteção
EXPORT int aud_drct_get_time ()
{
lock ();
int time = is_ready () ? output_get_time () : 0;
unlock ();
return time;
}
// thread de proteção
EXPORT int aud_drct_get_length ()
{
lock ();
int length = is_ready () ? pb_info.length : -1;
unlock ();
return length;
}
// thread de proteção
EXPORT void aud_drct_set_ab_repeat (int a, int b)
{
if (! pb_state.playing)
return;
lock ();
pb_control.repeat_a = a;
pb_control.repeat_b = b;
if (b >= 0 && is_ready () && output_get_time () >= b)
request_seek_locked (a);
unlock ();
}
// thread de proteção
EXPORT void aud_drct_get_ab_repeat (int & a, int & b)
{
lock ();
a = pb_control.repeat_a;
b = pb_control.repeat_b;
unlock ();}
