2016-12-20 16:37:36 +01:00
|
|
|
/*
|
2017-01-03 20:48:59 +01:00
|
|
|
* Copyright 2003-2017 The Music Player Daemon Project
|
2016-12-20 16:37:36 +01:00
|
|
|
* http://www.musicpd.org
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "config.h"
|
|
|
|
#include "Source.hxx"
|
|
|
|
#include "MusicChunk.hxx"
|
|
|
|
#include "filter/FilterInternal.hxx"
|
|
|
|
#include "filter/plugins/ReplayGainFilterPlugin.hxx"
|
|
|
|
#include "pcm/PcmMix.hxx"
|
2016-12-26 20:02:15 +01:00
|
|
|
#include "thread/Mutex.hxx"
|
2016-12-20 16:37:36 +01:00
|
|
|
#include "util/ConstBuffer.hxx"
|
|
|
|
#include "util/RuntimeError.hxx"
|
|
|
|
|
|
|
|
#include <string.h>
|
|
|
|
|
|
|
|
AudioFormat
|
2017-06-08 13:19:34 +02:00
|
|
|
AudioOutputSource::Open(const AudioFormat audio_format, const MusicPipe &_pipe,
|
2016-12-20 16:37:36 +01:00
|
|
|
PreparedFilter *prepared_replay_gain_filter,
|
|
|
|
PreparedFilter *prepared_other_replay_gain_filter,
|
|
|
|
PreparedFilter *prepared_filter)
|
|
|
|
{
|
|
|
|
assert(audio_format.IsValid());
|
|
|
|
|
|
|
|
if (!IsOpen() || &_pipe != &pipe.GetPipe())
|
|
|
|
pipe.Init(_pipe);
|
|
|
|
|
|
|
|
/* (re)open the filter */
|
|
|
|
|
|
|
|
if (filter_instance != nullptr &&
|
|
|
|
audio_format != in_audio_format)
|
|
|
|
/* the filter must be reopened on all input format
|
|
|
|
changes */
|
|
|
|
CloseFilter();
|
|
|
|
|
|
|
|
if (filter_instance == nullptr)
|
|
|
|
/* open the filter */
|
|
|
|
OpenFilter(audio_format,
|
|
|
|
prepared_replay_gain_filter,
|
|
|
|
prepared_other_replay_gain_filter,
|
|
|
|
prepared_filter);
|
|
|
|
|
|
|
|
in_audio_format = audio_format;
|
|
|
|
return filter_instance->GetOutAudioFormat();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2017-05-08 14:44:49 +02:00
|
|
|
AudioOutputSource::Close() noexcept
|
2016-12-20 16:37:36 +01:00
|
|
|
{
|
|
|
|
assert(in_audio_format.IsValid());
|
|
|
|
in_audio_format.Clear();
|
|
|
|
|
2017-01-03 10:49:09 +01:00
|
|
|
Cancel();
|
2016-12-20 16:37:36 +01:00
|
|
|
|
|
|
|
CloseFilter();
|
|
|
|
}
|
|
|
|
|
2017-01-11 15:39:00 +01:00
|
|
|
void
|
2017-05-08 14:44:49 +02:00
|
|
|
AudioOutputSource::Cancel() noexcept
|
2017-01-11 15:39:00 +01:00
|
|
|
{
|
|
|
|
current_chunk = nullptr;
|
|
|
|
pipe.Cancel();
|
2017-01-11 15:38:55 +01:00
|
|
|
|
|
|
|
if (replay_gain_filter_instance != nullptr)
|
|
|
|
replay_gain_filter_instance->Reset();
|
|
|
|
|
|
|
|
if (other_replay_gain_filter_instance != nullptr)
|
|
|
|
other_replay_gain_filter_instance->Reset();
|
|
|
|
|
|
|
|
if (filter_instance != nullptr)
|
|
|
|
filter_instance->Reset();
|
2017-01-11 15:39:00 +01:00
|
|
|
}
|
|
|
|
|
2016-12-20 16:37:36 +01:00
|
|
|
void
|
|
|
|
AudioOutputSource::OpenFilter(AudioFormat audio_format,
|
|
|
|
PreparedFilter *prepared_replay_gain_filter,
|
|
|
|
PreparedFilter *prepared_other_replay_gain_filter,
|
|
|
|
PreparedFilter *prepared_filter)
|
|
|
|
try {
|
|
|
|
assert(audio_format.IsValid());
|
|
|
|
|
|
|
|
/* the replay_gain filter cannot fail here */
|
2017-01-23 17:55:04 +01:00
|
|
|
if (prepared_replay_gain_filter != nullptr) {
|
|
|
|
replay_gain_serial = 0;
|
2016-12-20 16:37:36 +01:00
|
|
|
replay_gain_filter_instance =
|
|
|
|
prepared_replay_gain_filter->Open(audio_format);
|
2017-01-23 17:55:04 +01:00
|
|
|
}
|
2016-12-20 16:37:36 +01:00
|
|
|
|
2017-01-23 17:55:04 +01:00
|
|
|
if (prepared_other_replay_gain_filter != nullptr) {
|
|
|
|
other_replay_gain_serial = 0;
|
2016-12-20 16:37:36 +01:00
|
|
|
other_replay_gain_filter_instance =
|
|
|
|
prepared_other_replay_gain_filter->Open(audio_format);
|
2017-01-23 17:55:04 +01:00
|
|
|
}
|
2016-12-20 16:37:36 +01:00
|
|
|
|
|
|
|
filter_instance = prepared_filter->Open(audio_format);
|
|
|
|
} catch (...) {
|
|
|
|
CloseFilter();
|
|
|
|
throw;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2017-05-08 14:44:49 +02:00
|
|
|
AudioOutputSource::CloseFilter() noexcept
|
2016-12-20 16:37:36 +01:00
|
|
|
{
|
|
|
|
delete replay_gain_filter_instance;
|
|
|
|
replay_gain_filter_instance = nullptr;
|
|
|
|
|
|
|
|
delete other_replay_gain_filter_instance;
|
|
|
|
other_replay_gain_filter_instance = nullptr;
|
|
|
|
|
|
|
|
delete filter_instance;
|
|
|
|
filter_instance = nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
ConstBuffer<void>
|
|
|
|
AudioOutputSource::GetChunkData(const MusicChunk &chunk,
|
|
|
|
Filter *replay_gain_filter,
|
|
|
|
unsigned *replay_gain_serial_p)
|
|
|
|
{
|
|
|
|
assert(!chunk.IsEmpty());
|
|
|
|
assert(chunk.CheckFormat(in_audio_format));
|
|
|
|
|
|
|
|
ConstBuffer<void> data(chunk.data, chunk.length);
|
|
|
|
|
|
|
|
assert(data.size % in_audio_format.GetFrameSize() == 0);
|
|
|
|
|
2017-11-10 19:24:33 +01:00
|
|
|
if (!data.empty() && replay_gain_filter != nullptr) {
|
2016-12-20 16:37:36 +01:00
|
|
|
replay_gain_filter_set_mode(*replay_gain_filter,
|
|
|
|
replay_gain_mode);
|
|
|
|
|
2017-12-03 11:15:11 +01:00
|
|
|
if (chunk.replay_gain_serial != *replay_gain_serial_p &&
|
|
|
|
chunk.replay_gain_serial != MusicChunk::IGNORE_REPLAY_GAIN) {
|
2016-12-20 16:37:36 +01:00
|
|
|
replay_gain_filter_set_info(*replay_gain_filter,
|
|
|
|
chunk.replay_gain_serial != 0
|
|
|
|
? &chunk.replay_gain_info
|
|
|
|
: nullptr);
|
|
|
|
*replay_gain_serial_p = chunk.replay_gain_serial;
|
|
|
|
}
|
|
|
|
|
|
|
|
data = replay_gain_filter->FilterPCM(data);
|
|
|
|
}
|
|
|
|
|
|
|
|
return data;
|
|
|
|
}
|
|
|
|
|
|
|
|
ConstBuffer<void>
|
|
|
|
AudioOutputSource::FilterChunk(const MusicChunk &chunk)
|
|
|
|
{
|
|
|
|
auto data = GetChunkData(chunk, replay_gain_filter_instance,
|
|
|
|
&replay_gain_serial);
|
2017-11-10 19:24:33 +01:00
|
|
|
if (data.empty())
|
2016-12-20 16:37:36 +01:00
|
|
|
return data;
|
|
|
|
|
|
|
|
/* cross-fade */
|
|
|
|
|
|
|
|
if (chunk.other != nullptr) {
|
|
|
|
auto other_data = GetChunkData(*chunk.other,
|
|
|
|
other_replay_gain_filter_instance,
|
|
|
|
&other_replay_gain_serial);
|
2017-11-10 19:24:33 +01:00
|
|
|
if (other_data.empty())
|
2016-12-20 16:37:36 +01:00
|
|
|
return data;
|
|
|
|
|
|
|
|
/* if the "other" chunk is longer, then that trailer
|
|
|
|
is used as-is, without mixing; it is part of the
|
|
|
|
"next" song being faded in, and if there's a rest,
|
|
|
|
it means cross-fading ends here */
|
|
|
|
|
|
|
|
if (data.size > other_data.size)
|
|
|
|
data.size = other_data.size;
|
|
|
|
|
|
|
|
float mix_ratio = chunk.mix_ratio;
|
|
|
|
if (mix_ratio >= 0)
|
|
|
|
/* reverse the mix ratio (because the
|
|
|
|
arguments to pcm_mix() are reversed), but
|
|
|
|
only if the mix ratio is non-negative; a
|
|
|
|
negative mix ratio is a MixRamp special
|
|
|
|
case */
|
|
|
|
mix_ratio = 1.0 - mix_ratio;
|
|
|
|
|
|
|
|
void *dest = cross_fade_buffer.Get(other_data.size);
|
|
|
|
memcpy(dest, other_data.data, other_data.size);
|
|
|
|
if (!pcm_mix(cross_fade_dither, dest, data.data, data.size,
|
|
|
|
in_audio_format.format,
|
|
|
|
mix_ratio))
|
|
|
|
throw FormatRuntimeError("Cannot cross-fade format %s",
|
|
|
|
sample_format_to_string(in_audio_format.format));
|
|
|
|
|
|
|
|
data.data = dest;
|
|
|
|
data.size = other_data.size;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* apply filter chain */
|
|
|
|
|
|
|
|
return filter_instance->FilterPCM(data);
|
|
|
|
}
|
2016-12-26 13:53:22 +01:00
|
|
|
|
|
|
|
bool
|
2016-12-26 20:02:15 +01:00
|
|
|
AudioOutputSource::Fill(Mutex &mutex)
|
2016-12-26 13:53:22 +01:00
|
|
|
{
|
|
|
|
if (current_chunk != nullptr && pending_tag == nullptr &&
|
2017-11-10 19:24:33 +01:00
|
|
|
pending_data.empty())
|
2016-12-26 13:53:22 +01:00
|
|
|
pipe.Consume(*std::exchange(current_chunk, nullptr));
|
|
|
|
|
|
|
|
if (current_chunk != nullptr)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
current_chunk = pipe.Get();
|
|
|
|
if (current_chunk == nullptr)
|
|
|
|
return false;
|
|
|
|
|
2017-12-20 14:43:29 +01:00
|
|
|
pending_tag = current_chunk->tag.get();
|
2016-12-26 13:53:22 +01:00
|
|
|
|
|
|
|
try {
|
2016-12-26 20:02:15 +01:00
|
|
|
/* release the mutex while the filter runs, because
|
|
|
|
that may take a while */
|
|
|
|
const ScopeUnlock unlock(mutex);
|
|
|
|
|
2016-12-26 13:53:22 +01:00
|
|
|
pending_data = pending_data.FromVoid(FilterChunk(*current_chunk));
|
|
|
|
} catch (...) {
|
|
|
|
current_chunk = nullptr;
|
|
|
|
throw;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
AudioOutputSource::ConsumeData(size_t nbytes) noexcept
|
|
|
|
{
|
|
|
|
pending_data.skip_front(nbytes);
|
|
|
|
|
2017-11-10 19:24:33 +01:00
|
|
|
if (pending_data.empty())
|
2016-12-26 13:53:22 +01:00
|
|
|
pipe.Consume(*std::exchange(current_chunk, nullptr));
|
|
|
|
}
|