2013-10-25 19:09:22 +02:00
|
|
|
|
2009-03-13 18:43:16 +01:00
|
|
|
/*
|
2013-01-04 09:46:41 +01:00
|
|
|
* Copyright (C) 2003-2013 The Music Player Daemon Project
|
2009-03-13 18:43:16 +01:00
|
|
|
* http://www.musicpd.org
|
2008-09-09 10:02:34 +02:00
|
|
|
*
|
|
|
|
* This program 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.
|
|
|
|
*
|
|
|
|
* This program 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.
|
2009-03-13 18:43:16 +01:00
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License along
|
|
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
2008-09-09 10:02:34 +02:00
|
|
|
*/
|
|
|
|
|
2009-11-12 09:12:38 +01:00
|
|
|
#include "config.h"
|
2013-01-04 09:46:41 +01:00
|
|
|
#include "OutputControl.hxx"
|
|
|
|
#include "OutputThread.hxx"
|
2013-04-17 01:12:05 +02:00
|
|
|
#include "OutputInternal.hxx"
|
|
|
|
#include "OutputPlugin.hxx"
|
2013-09-27 22:31:24 +02:00
|
|
|
#include "OutputError.hxx"
|
2013-02-22 20:51:23 +01:00
|
|
|
#include "MixerPlugin.hxx"
|
|
|
|
#include "MixerControl.hxx"
|
2013-01-10 10:44:04 +01:00
|
|
|
#include "notify.hxx"
|
2013-01-07 10:12:51 +01:00
|
|
|
#include "filter/ReplayGainFilterPlugin.hxx"
|
2013-02-01 17:47:09 +01:00
|
|
|
#include "FilterPlugin.hxx"
|
2013-08-10 18:02:44 +02:00
|
|
|
#include "util/Error.hxx"
|
2013-09-27 22:31:24 +02:00
|
|
|
#include "Log.hxx"
|
2008-09-24 07:20:26 +02:00
|
|
|
|
2013-09-27 22:56:30 +02:00
|
|
|
#include <glib.h>
|
|
|
|
|
2008-10-08 10:49:29 +02:00
|
|
|
#include <assert.h>
|
|
|
|
#include <stdlib.h>
|
2008-09-24 07:20:26 +02:00
|
|
|
|
2013-10-20 13:52:26 +02:00
|
|
|
/** after a failure, wait this number of seconds before
|
|
|
|
automatically reopening the device */
|
|
|
|
static constexpr unsigned REOPEN_AFTER = 10;
|
2009-02-28 20:43:23 +01:00
|
|
|
|
2008-12-27 20:53:52 +01:00
|
|
|
struct notify audio_output_client_notify;
|
2008-09-24 07:20:26 +02:00
|
|
|
|
2011-01-10 22:16:44 +01:00
|
|
|
/**
|
|
|
|
* Waits for command completion.
|
|
|
|
*
|
|
|
|
* @param ao the #audio_output instance; must be locked
|
|
|
|
*/
|
2008-09-24 07:20:26 +02:00
|
|
|
static void ao_command_wait(struct audio_output *ao)
|
|
|
|
{
|
|
|
|
while (ao->command != AO_COMMAND_NONE) {
|
2013-04-17 01:19:25 +02:00
|
|
|
ao->mutex.unlock();
|
2013-01-10 10:44:04 +01:00
|
|
|
audio_output_client_notify.Wait();
|
2013-04-17 01:19:25 +02:00
|
|
|
ao->mutex.lock();
|
2008-09-24 07:20:26 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-01-10 22:16:44 +01:00
|
|
|
/**
|
|
|
|
* Sends a command to the #audio_output object, but does not wait for
|
|
|
|
* completion.
|
|
|
|
*
|
|
|
|
* @param ao the #audio_output instance; must be locked
|
|
|
|
*/
|
2011-01-10 21:52:38 +01:00
|
|
|
static void ao_command_async(struct audio_output *ao,
|
|
|
|
enum audio_output_command cmd)
|
2008-09-24 07:20:26 +02:00
|
|
|
{
|
|
|
|
assert(ao->command == AO_COMMAND_NONE);
|
|
|
|
ao->command = cmd;
|
2013-04-17 01:19:25 +02:00
|
|
|
ao->cond.signal();
|
2008-09-24 07:20:26 +02:00
|
|
|
}
|
2008-09-09 10:02:34 +02:00
|
|
|
|
2011-01-10 22:16:44 +01:00
|
|
|
/**
|
|
|
|
* Sends a command to the #audio_output object and waits for
|
|
|
|
* completion.
|
|
|
|
*
|
|
|
|
* @param ao the #audio_output instance; must be locked
|
|
|
|
*/
|
2011-01-10 21:52:38 +01:00
|
|
|
static void
|
|
|
|
ao_command(struct audio_output *ao, enum audio_output_command cmd)
|
2008-09-24 07:23:19 +02:00
|
|
|
{
|
2011-01-10 21:52:38 +01:00
|
|
|
ao_command_async(ao, cmd);
|
|
|
|
ao_command_wait(ao);
|
2008-09-24 07:23:19 +02:00
|
|
|
}
|
|
|
|
|
2011-01-10 21:54:43 +01:00
|
|
|
/**
|
|
|
|
* Lock the #audio_output object and execute the command
|
|
|
|
* synchronously.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
ao_lock_command(struct audio_output *ao, enum audio_output_command cmd)
|
|
|
|
{
|
2013-04-17 01:19:25 +02:00
|
|
|
const ScopeLock protect(ao->mutex);
|
2011-01-10 21:54:43 +01:00
|
|
|
ao_command(ao, cmd);
|
|
|
|
}
|
|
|
|
|
2013-01-05 00:05:57 +01:00
|
|
|
void
|
|
|
|
audio_output_set_replay_gain_mode(struct audio_output *ao,
|
2013-10-25 19:09:22 +02:00
|
|
|
ReplayGainMode mode)
|
2013-01-05 00:05:57 +01:00
|
|
|
{
|
2013-10-19 18:19:03 +02:00
|
|
|
if (ao->replay_gain_filter != nullptr)
|
2013-01-05 00:05:57 +01:00
|
|
|
replay_gain_filter_set_mode(ao->replay_gain_filter, mode);
|
2013-12-24 11:51:37 +01:00
|
|
|
if (ao->other_replay_gain_filter != nullptr)
|
|
|
|
replay_gain_filter_set_mode(ao->other_replay_gain_filter, mode);
|
2013-01-05 00:05:57 +01:00
|
|
|
}
|
|
|
|
|
2009-10-23 10:55:52 +02:00
|
|
|
void
|
|
|
|
audio_output_enable(struct audio_output *ao)
|
|
|
|
{
|
2013-10-17 18:42:14 +02:00
|
|
|
if (!ao->thread.IsDefined()) {
|
2013-10-19 18:19:03 +02:00
|
|
|
if (ao->plugin->enable == nullptr) {
|
2009-10-23 10:55:52 +02:00
|
|
|
/* don't bother to start the thread now if the
|
|
|
|
device doesn't even have a enable() method;
|
|
|
|
just assign the variable and we're done */
|
|
|
|
ao->really_enabled = true;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
audio_output_thread_start(ao);
|
|
|
|
}
|
|
|
|
|
2011-01-10 21:54:43 +01:00
|
|
|
ao_lock_command(ao, AO_COMMAND_ENABLE);
|
2009-10-23 10:55:52 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
audio_output_disable(struct audio_output *ao)
|
|
|
|
{
|
2013-10-17 18:42:14 +02:00
|
|
|
if (!ao->thread.IsDefined()) {
|
2013-10-19 18:19:03 +02:00
|
|
|
if (ao->plugin->disable == nullptr)
|
2009-10-23 10:55:52 +02:00
|
|
|
ao->really_enabled = false;
|
|
|
|
else
|
|
|
|
/* if there's no thread yet, the device cannot
|
|
|
|
be enabled */
|
|
|
|
assert(!ao->really_enabled);
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-01-10 21:54:43 +01:00
|
|
|
ao_lock_command(ao, AO_COMMAND_DISABLE);
|
2009-10-23 10:55:52 +02:00
|
|
|
}
|
|
|
|
|
2010-11-04 22:47:51 +01:00
|
|
|
/**
|
|
|
|
* Object must be locked (and unlocked) by the caller.
|
|
|
|
*/
|
2009-03-09 19:11:13 +01:00
|
|
|
static bool
|
2009-02-16 00:43:06 +01:00
|
|
|
audio_output_open(struct audio_output *ao,
|
2013-08-03 21:00:50 +02:00
|
|
|
const AudioFormat audio_format,
|
2013-09-26 21:51:45 +02:00
|
|
|
const MusicPipe &mp)
|
2008-09-09 10:02:34 +02:00
|
|
|
{
|
2009-03-26 18:23:23 +01:00
|
|
|
bool open;
|
|
|
|
|
2013-10-19 18:19:03 +02:00
|
|
|
assert(ao != nullptr);
|
2011-09-01 07:13:21 +02:00
|
|
|
assert(ao->allow_play);
|
2013-08-03 21:00:50 +02:00
|
|
|
assert(audio_format.IsValid());
|
2009-03-09 19:25:26 +01:00
|
|
|
|
2013-10-19 18:19:03 +02:00
|
|
|
if (ao->fail_timer != nullptr) {
|
2009-02-28 20:43:23 +01:00
|
|
|
g_timer_destroy(ao->fail_timer);
|
2013-10-19 18:19:03 +02:00
|
|
|
ao->fail_timer = nullptr;
|
2009-02-28 20:43:23 +01:00
|
|
|
}
|
2008-10-29 22:32:50 +01:00
|
|
|
|
2013-08-03 21:00:50 +02:00
|
|
|
if (ao->open && audio_format == ao->in_audio_format) {
|
2013-09-26 21:51:45 +02:00
|
|
|
assert(ao->pipe == &mp ||
|
2010-03-03 20:29:33 +01:00
|
|
|
(ao->always_on && ao->pause));
|
2009-03-09 19:25:26 +01:00
|
|
|
|
2009-08-14 11:52:12 +02:00
|
|
|
if (ao->pause) {
|
2013-10-19 18:19:03 +02:00
|
|
|
ao->chunk = nullptr;
|
2013-09-26 21:51:45 +02:00
|
|
|
ao->pipe = ∓
|
2010-03-03 20:29:33 +01:00
|
|
|
|
2009-08-14 11:52:12 +02:00
|
|
|
/* unpause with the CANCEL command; this is a
|
|
|
|
hack, but suits well for forcing the thread
|
|
|
|
to leave the ao_pause() thread, and we need
|
|
|
|
to flush the device buffer anyway */
|
|
|
|
|
|
|
|
/* we're not using audio_output_cancel() here,
|
|
|
|
because that function is asynchronous */
|
|
|
|
ao_command(ao, AO_COMMAND_CANCEL);
|
|
|
|
}
|
|
|
|
|
2008-10-29 20:40:27 +01:00
|
|
|
return true;
|
2008-09-09 10:02:34 +02:00
|
|
|
}
|
|
|
|
|
2013-08-03 21:00:50 +02:00
|
|
|
ao->in_audio_format = audio_format;
|
2013-10-19 18:19:03 +02:00
|
|
|
ao->chunk = nullptr;
|
2008-09-09 10:02:34 +02:00
|
|
|
|
2013-09-26 21:51:45 +02:00
|
|
|
ao->pipe = ∓
|
2009-03-09 19:25:26 +01:00
|
|
|
|
2013-10-17 18:42:14 +02:00
|
|
|
if (!ao->thread.IsDefined())
|
2009-02-16 00:43:06 +01:00
|
|
|
audio_output_thread_start(ao);
|
2008-09-09 10:02:34 +02:00
|
|
|
|
2009-07-06 10:01:02 +02:00
|
|
|
ao_command(ao, ao->open ? AO_COMMAND_REOPEN : AO_COMMAND_OPEN);
|
2009-03-26 18:23:23 +01:00
|
|
|
open = ao->open;
|
2008-09-09 10:02:34 +02:00
|
|
|
|
2013-10-19 18:19:03 +02:00
|
|
|
if (open && ao->mixer != nullptr) {
|
2013-08-10 18:02:44 +02:00
|
|
|
Error error;
|
|
|
|
if (!mixer_open(ao->mixer, error))
|
2013-09-27 22:31:24 +02:00
|
|
|
FormatWarning(output_domain,
|
|
|
|
"Failed to open mixer for '%s'",
|
|
|
|
ao->name);
|
2009-10-20 22:10:56 +02:00
|
|
|
}
|
2009-03-26 18:23:23 +01:00
|
|
|
|
|
|
|
return open;
|
2008-09-09 10:02:34 +02:00
|
|
|
}
|
|
|
|
|
2009-10-29 22:39:42 +01:00
|
|
|
/**
|
|
|
|
* Same as audio_output_close(), but expects the lock to be held by
|
|
|
|
* the caller.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
audio_output_close_locked(struct audio_output *ao)
|
|
|
|
{
|
2013-10-19 18:19:03 +02:00
|
|
|
assert(ao != nullptr);
|
2011-09-01 07:13:21 +02:00
|
|
|
assert(ao->allow_play);
|
2010-11-07 15:30:18 +01:00
|
|
|
|
2013-10-19 18:19:03 +02:00
|
|
|
if (ao->mixer != nullptr)
|
2009-10-29 22:39:42 +01:00
|
|
|
mixer_auto_close(ao->mixer);
|
|
|
|
|
2013-10-19 18:19:03 +02:00
|
|
|
assert(!ao->open || ao->fail_timer == nullptr);
|
2009-10-29 22:39:42 +01:00
|
|
|
|
|
|
|
if (ao->open)
|
|
|
|
ao_command(ao, AO_COMMAND_CLOSE);
|
2013-10-19 18:19:03 +02:00
|
|
|
else if (ao->fail_timer != nullptr) {
|
2009-10-29 22:39:42 +01:00
|
|
|
g_timer_destroy(ao->fail_timer);
|
2013-10-19 18:19:03 +02:00
|
|
|
ao->fail_timer = nullptr;
|
2009-10-29 22:39:42 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-03-07 19:55:57 +01:00
|
|
|
bool
|
2008-10-29 22:17:44 +01:00
|
|
|
audio_output_update(struct audio_output *ao,
|
2013-08-03 21:00:50 +02:00
|
|
|
const AudioFormat audio_format,
|
2013-09-26 21:51:45 +02:00
|
|
|
const MusicPipe &mp)
|
2008-10-29 22:17:44 +01:00
|
|
|
{
|
2013-04-17 01:19:25 +02:00
|
|
|
const ScopeLock protect(ao->mutex);
|
2009-10-29 17:06:40 +01:00
|
|
|
|
2009-10-23 10:55:52 +02:00
|
|
|
if (ao->enabled && ao->really_enabled) {
|
2013-10-19 18:19:03 +02:00
|
|
|
if (ao->fail_timer == nullptr ||
|
|
|
|
g_timer_elapsed(ao->fail_timer, nullptr) > REOPEN_AFTER) {
|
2013-04-17 01:19:25 +02:00
|
|
|
return audio_output_open(ao, audio_format, mp);
|
2009-10-29 17:06:40 +01:00
|
|
|
}
|
2008-10-29 22:32:50 +01:00
|
|
|
} else if (audio_output_is_open(ao))
|
2009-10-29 22:39:42 +01:00
|
|
|
audio_output_close_locked(ao);
|
2009-03-07 19:55:57 +01:00
|
|
|
|
|
|
|
return false;
|
2008-10-29 22:17:44 +01:00
|
|
|
}
|
|
|
|
|
2009-02-16 00:43:06 +01:00
|
|
|
void
|
2009-03-09 19:25:26 +01:00
|
|
|
audio_output_play(struct audio_output *ao)
|
2008-09-09 10:02:34 +02:00
|
|
|
{
|
2013-04-17 01:19:25 +02:00
|
|
|
const ScopeLock protect(ao->mutex);
|
2008-09-09 10:02:34 +02:00
|
|
|
|
2011-09-01 07:13:21 +02:00
|
|
|
assert(ao->allow_play);
|
|
|
|
|
2013-11-06 23:47:30 +01:00
|
|
|
if (audio_output_is_open(ao) && !ao->in_playback_loop &&
|
|
|
|
!ao->woken_for_play) {
|
|
|
|
ao->woken_for_play = true;
|
2013-04-17 01:19:25 +02:00
|
|
|
ao->cond.signal();
|
2013-11-06 23:47:30 +01:00
|
|
|
}
|
2008-09-09 10:02:34 +02:00
|
|
|
}
|
|
|
|
|
2009-02-16 00:43:06 +01:00
|
|
|
void audio_output_pause(struct audio_output *ao)
|
2008-09-29 16:43:55 +02:00
|
|
|
{
|
2013-10-19 18:19:03 +02:00
|
|
|
if (ao->mixer != nullptr && ao->plugin->pause == nullptr)
|
2009-04-21 22:17:52 +02:00
|
|
|
/* the device has no pause mode: close the mixer,
|
|
|
|
unless its "global" flag is set (checked by
|
|
|
|
mixer_auto_close()) */
|
|
|
|
mixer_auto_close(ao->mixer);
|
|
|
|
|
2013-04-17 01:19:25 +02:00
|
|
|
const ScopeLock protect(ao->mutex);
|
|
|
|
|
2011-09-01 07:13:21 +02:00
|
|
|
assert(ao->allow_play);
|
2009-10-29 17:06:40 +01:00
|
|
|
if (audio_output_is_open(ao))
|
|
|
|
ao_command_async(ao, AO_COMMAND_PAUSE);
|
2008-09-29 16:43:55 +02:00
|
|
|
}
|
|
|
|
|
2009-11-09 22:16:26 +01:00
|
|
|
void
|
|
|
|
audio_output_drain_async(struct audio_output *ao)
|
|
|
|
{
|
2013-04-17 01:19:25 +02:00
|
|
|
const ScopeLock protect(ao->mutex);
|
|
|
|
|
2011-09-01 07:13:21 +02:00
|
|
|
assert(ao->allow_play);
|
2009-11-09 22:16:26 +01:00
|
|
|
if (audio_output_is_open(ao))
|
|
|
|
ao_command_async(ao, AO_COMMAND_DRAIN);
|
|
|
|
}
|
|
|
|
|
2009-02-16 00:43:06 +01:00
|
|
|
void audio_output_cancel(struct audio_output *ao)
|
2008-09-09 10:02:34 +02:00
|
|
|
{
|
2013-04-17 01:19:25 +02:00
|
|
|
const ScopeLock protect(ao->mutex);
|
2011-09-01 07:13:21 +02:00
|
|
|
|
|
|
|
if (audio_output_is_open(ao)) {
|
|
|
|
ao->allow_play = false;
|
2009-10-29 17:06:40 +01:00
|
|
|
ao_command_async(ao, AO_COMMAND_CANCEL);
|
2011-09-01 07:13:21 +02:00
|
|
|
}
|
2011-09-01 07:53:42 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
audio_output_allow_play(struct audio_output *ao)
|
|
|
|
{
|
2013-04-17 01:19:25 +02:00
|
|
|
const ScopeLock protect(ao->mutex);
|
2011-09-01 07:53:42 +02:00
|
|
|
|
|
|
|
ao->allow_play = true;
|
|
|
|
if (audio_output_is_open(ao))
|
2013-04-17 01:19:25 +02:00
|
|
|
ao->cond.signal();
|
2008-09-09 10:02:34 +02:00
|
|
|
}
|
|
|
|
|
2010-03-03 20:29:33 +01:00
|
|
|
void
|
|
|
|
audio_output_release(struct audio_output *ao)
|
|
|
|
{
|
|
|
|
if (ao->always_on)
|
|
|
|
audio_output_pause(ao);
|
|
|
|
else
|
|
|
|
audio_output_close(ao);
|
|
|
|
}
|
|
|
|
|
2010-11-04 21:51:02 +01:00
|
|
|
void audio_output_close(struct audio_output *ao)
|
|
|
|
{
|
2013-10-19 18:19:03 +02:00
|
|
|
assert(ao != nullptr);
|
|
|
|
assert(!ao->open || ao->fail_timer == nullptr);
|
2010-11-04 21:51:02 +01:00
|
|
|
|
2013-04-17 01:19:25 +02:00
|
|
|
const ScopeLock protect(ao->mutex);
|
2010-11-04 21:51:02 +01:00
|
|
|
audio_output_close_locked(ao);
|
|
|
|
}
|
|
|
|
|
2009-02-16 00:43:06 +01:00
|
|
|
void audio_output_finish(struct audio_output *ao)
|
2008-09-09 10:02:34 +02:00
|
|
|
{
|
2009-02-16 00:43:06 +01:00
|
|
|
audio_output_close(ao);
|
2009-01-07 23:55:13 +01:00
|
|
|
|
2013-10-19 18:19:03 +02:00
|
|
|
assert(ao->fail_timer == nullptr);
|
2009-02-28 20:43:23 +01:00
|
|
|
|
2013-10-17 18:42:14 +02:00
|
|
|
if (ao->thread.IsDefined()) {
|
2011-09-01 07:13:21 +02:00
|
|
|
assert(ao->allow_play);
|
2011-01-10 21:54:43 +01:00
|
|
|
ao_lock_command(ao, AO_COMMAND_KILL);
|
2013-10-17 18:42:14 +02:00
|
|
|
ao->thread.Join();
|
2009-01-07 23:55:13 +01:00
|
|
|
}
|
|
|
|
|
2011-09-16 23:31:48 +02:00
|
|
|
audio_output_free(ao);
|
2008-09-09 10:02:34 +02:00
|
|
|
}
|