Aegisub/src/audio_player_alsa.cpp

384 lines
10 KiB
C++
Raw Permalink Normal View History

// Copyright (c) 2011, Niels Martin Hansen
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// * Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
// * Neither the name of the Aegisub Group nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
// Aegisub Project http://www.aegisub.org/
/// @file audio_player_alsa.cpp
/// @brief ALSA-based audio output
/// @ingroup audio_output
///
#ifdef WITH_ALSA
2014-03-24 15:54:22 +01:00
#include "include/aegisub/audio_player.h"
#include "audio_controller.h"
#include "compat.h"
#include "frame_main.h"
#include "options.h"
#include <libaegisub/audio/provider.h>
2013-10-24 22:17:53 +02:00
#include <libaegisub/log.h>
#include <libaegisub/make_unique.h>
2013-10-24 22:17:53 +02:00
#include <atomic>
#include <algorithm>
#include <boost/scope_exit.hpp>
#include <chrono>
#include <condition_variable>
2014-03-24 15:54:22 +01:00
#include <alsa/asoundlib.h>
#include <memory>
#include <mutex>
#include <thread>
// X11 is the bestest
#undef None
2014-03-24 15:54:22 +01:00
namespace {
enum class Message {
None,
Start,
Stop,
Close
};
2014-03-24 15:54:22 +01:00
using clock = std::chrono::steady_clock;
class AlsaPlayer final : public AudioPlayer {
std::mutex mutex;
std::condition_variable cond;
2014-03-24 15:54:22 +01:00
std::string device_name = OPT_GET("Player/Audio/ALSA/Device")->GetString();
2014-03-24 15:54:22 +01:00
Message message = Message::None;
2014-03-24 15:54:22 +01:00
std::atomic<bool> playing{false};
std::atomic<double> volume{1.0};
int64_t start_position = 0;
std::atomic<int64_t> end_position{0};
bool fallback_mono16 = false; // whether to convert to 16 bit mono. FIXME: more flexible conversion
2014-03-24 15:54:22 +01:00
std::mutex position_mutex;
2014-03-24 15:54:22 +01:00
int64_t last_position = 0;
clock::time_point last_position_time;
2014-03-24 15:54:22 +01:00
std::vector<char> decode_buffer;
std::thread thread;
2014-03-24 15:54:22 +01:00
snd_pcm_format_t GetPCMFormat(const agi::AudioProvider *provider);
void PlaybackThread();
2014-03-24 15:54:22 +01:00
void UpdatePlaybackPosition(snd_pcm_t *pcm, int64_t position)
{
snd_pcm_sframes_t delay;
if (snd_pcm_delay(pcm, &delay) == 0)
{
std::unique_lock<std::mutex> playback_lock;
last_position = position - delay;
last_position_time = clock::now();
}
}
2014-03-24 15:54:22 +01:00
public:
AlsaPlayer(agi::AudioProvider *provider);
2014-03-24 15:54:22 +01:00
~AlsaPlayer();
void Play(int64_t start, int64_t count) override;
void Stop() override;
bool IsPlaying() override { return playing; }
void SetVolume(double vol) override { volume = vol; }
int64_t GetEndPosition() override { return end_position; }
int64_t GetCurrentPosition() override;
void SetEndPosition(int64_t pos) override;
};
snd_pcm_format_t AlsaPlayer::GetPCMFormat(const agi::AudioProvider *provider) {
if (provider->AreSamplesFloat()) {
switch (provider->GetBytesPerSample()) {
case 4:
return SND_PCM_FORMAT_FLOAT_LE;
case 8:
return SND_PCM_FORMAT_FLOAT64_LE;
default:
fallback_mono16 = true;
return SND_PCM_FORMAT_S16_LE;
}
} else {
switch (provider->GetBytesPerSample()) {
case 1:
return SND_PCM_FORMAT_U8;
case 2:
return SND_PCM_FORMAT_S16_LE;
case 3:
return SND_PCM_FORMAT_S24_LE;
case 4:
return SND_PCM_FORMAT_S32_LE;
case 8:
return SND_PCM_FORMAT_S32_LE;
default:
fallback_mono16 = true;
return SND_PCM_FORMAT_S16_LE;
}
}
}
void AlsaPlayer::PlaybackThread()
{
std::unique_lock<std::mutex> lock(mutex);
snd_pcm_t *pcm = nullptr;
if (snd_pcm_open(&pcm, device_name.c_str(), SND_PCM_STREAM_PLAYBACK, 0) != 0)
return;
LOG_D("audio/player/alsa") << "opened pcm";
BOOST_SCOPE_EXIT_ALL(&) { snd_pcm_close(pcm); };
do_setup:
snd_pcm_format_t pcm_format = GetPCMFormat(provider);
if (snd_pcm_set_params(pcm,
pcm_format,
SND_PCM_ACCESS_RW_INTERLEAVED,
fallback_mono16 ? 1 : provider->GetChannels(),
provider->GetSampleRate(),
1, // allow resample
100*1000 // 100 milliseconds latency
) != 0)
return;
LOG_D("audio/player/alsa") << "set pcm params";
size_t framesize = fallback_mono16 ? sizeof(int16_t) : provider->GetChannels() * provider->GetBytesPerSample();
while (true)
{
// Wait for condition to trigger
while (message != Message::Start)
{
cond.wait(lock, [&] { return message != Message::None; });
if (message == Message::Close)
return;
if (message == Message::Start && end_position > start_position)
break;
// Not playing, so don't need to stop...
message = Message::None;
}
message = Message::None;
LOG_D("audio/player/alsa") << "starting playback";
int64_t position = start_position;
// Initial buffer-fill
{
auto avail = std::min(snd_pcm_avail(pcm), (snd_pcm_sframes_t)(end_position-position));
decode_buffer.resize(avail * framesize);
if (fallback_mono16) {
provider->GetInt16MonoAudioWithVolume(reinterpret_cast<int16_t*>(decode_buffer.data()), position, avail, volume);
} else {
provider->GetAudioWithVolume(decode_buffer.data(), position, avail, volume);
}
2014-05-23 04:51:55 +02:00
snd_pcm_sframes_t written = 0;
while (written <= 0)
{
written = snd_pcm_writei(pcm, decode_buffer.data(), avail);
2014-05-23 04:51:55 +02:00
if (written == -ESTRPIPE)
snd_pcm_recover(pcm, written, 0);
else if (written <= 0)
{
LOG_D("audio/player/alsa") << "error filling buffer";
return;
2014-05-23 04:51:55 +02:00
}
}
2014-05-23 04:51:55 +02:00
position += written;
}
// Start playback
LOG_D("audio/player/alsa") << "initial buffer filled, hitting start";
snd_pcm_start(pcm);
UpdatePlaybackPosition(pcm, position);
playing = true;
BOOST_SCOPE_EXIT_ALL(&) { playing = false; };
while (true)
{
// Sleep a bit, or until an event
cond.wait_for(lock, std::chrono::milliseconds{25});
if (message == Message::Close)
{
snd_pcm_drop(pcm);
return;
}
// Check for stop signal
if (message == Message::Stop || message == Message::Start)
{
LOG_D("audio/player/alsa") << "playback loop, stop signal";
snd_pcm_drop(pcm);
break;
}
// Fill buffer
snd_pcm_sframes_t tmp_pcm_avail = snd_pcm_avail(pcm);
if (tmp_pcm_avail == -EPIPE)
{
if (snd_pcm_recover(pcm, -EPIPE, 1) < 0)
{
LOG_D("audio/player/alsa") << "failed to recover from underrun";
return;
}
tmp_pcm_avail = snd_pcm_avail(pcm);
}
auto avail = std::min(tmp_pcm_avail, (snd_pcm_sframes_t)(end_position-position));
if (avail < 0)
continue;
2014-05-23 04:51:55 +02:00
{
decode_buffer.resize(avail * framesize);
if (fallback_mono16) {
provider->GetInt16MonoAudioWithVolume(reinterpret_cast<int16_t*>(decode_buffer.data()), position, avail, volume);
} else {
provider->GetAudioWithVolume(decode_buffer.data(), position, avail, volume);
}
2014-05-23 04:51:55 +02:00
snd_pcm_sframes_t written = 0;
while (written <= 0)
{
written = snd_pcm_writei(pcm, decode_buffer.data(), avail);
2014-05-23 04:51:55 +02:00
if (written == -ESTRPIPE || written == -EPIPE)
snd_pcm_recover(pcm, written, 0);
else if (written == 0)
break;
else if (written < 0)
{
LOG_D("audio/player/alsa") << "error filling buffer, written=" << written;
return;
2014-05-23 04:51:55 +02:00
}
}
2014-05-23 04:51:55 +02:00
position += written;
}
UpdatePlaybackPosition(pcm, position);
// Check for end of playback
if (position >= end_position)
{
LOG_D("audio/player/alsa") << "playback loop, past end, draining";
snd_pcm_drain(pcm);
break;
}
}
playing = false;
LOG_D("audio/player/alsa") << "out of playback loop";
switch (snd_pcm_state(pcm))
{
case SND_PCM_STATE_OPEN:
// no clue what could have happened here, but start over
goto do_setup;
case SND_PCM_STATE_SETUP:
// we lost the preparedness?
snd_pcm_prepare(pcm);
break;
case SND_PCM_STATE_DISCONNECTED:
// lost device, close the handle and return error
return;
default:
// everything else should either be fine or impossible (here)
break;
}
}
}
AlsaPlayer::AlsaPlayer(agi::AudioProvider *provider) try
: AudioPlayer(provider)
, thread(&AlsaPlayer::PlaybackThread, this)
{
}
catch (std::system_error const&) {
throw AudioPlayerOpenError("AlsaPlayer: Creating the playback thread failed");
}
AlsaPlayer::~AlsaPlayer()
{
{
std::unique_lock<std::mutex> lock(mutex);
message = Message::Close;
cond.notify_all();
}
thread.join();
}
void AlsaPlayer::Play(int64_t start, int64_t count)
{
std::unique_lock<std::mutex> lock(mutex);
message = Message::Start;
start_position = start;
end_position = start + count;
cond.notify_all();
}
void AlsaPlayer::Stop()
{
std::unique_lock<std::mutex> lock(mutex);
message = Message::Stop;
cond.notify_all();
}
void AlsaPlayer::SetEndPosition(int64_t pos)
{
std::unique_lock<std::mutex> lock(mutex);
end_position = pos;
}
int64_t AlsaPlayer::GetCurrentPosition()
{
int64_t lastpos;
clock::time_point lasttime;
{
std::unique_lock<std::mutex> playback_lock;
lastpos = last_position;
lasttime = last_position_time;
}
auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(clock::now() - lasttime).count();
return lastpos + ms * provider->GetSampleRate() / 1000;
2014-03-24 15:54:22 +01:00
}
}
std::unique_ptr<AudioPlayer> CreateAlsaPlayer(agi::AudioProvider *provider, wxWindow *)
2014-03-24 15:54:22 +01:00
{
return agi::make_unique<AlsaPlayer>(provider);
}
#endif // WITH_ALSA