ShuriZma
/
dolphin
mirror of https://github.com/dolphin-emu/dolphin.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

use pulseaudio "simple" api

This commit is contained in:
Jordan Woyak 2013-01-09 17:39:19 -06:00
parent 32855a289c
commit 488a679ca7
4 changed files with 56 additions and 267 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Source/Core/AudioCommon/CMakeLists.txt
View File

@ -23,7 +23,8 @@ endif(OPENAL_FOUND)
if(PULSEAUDIO_FOUND) if(PULSEAUDIO_FOUND)
set(SRCS ${SRCS} Src/PulseAudioStream.cpp) set(SRCS ${SRCS} Src/PulseAudioStream.cpp)
set(LIBS ${LIBS} ${PULSEAUDIO_LIBRARIES}) # TODO: remove hacks
set(LIBS ${LIBS} ${PULSEAUDIO_LIBRARIES} pulse-simple)
endif(PULSEAUDIO_FOUND) endif(PULSEAUDIO_FOUND)
if(WIN32) if(WIN32)

292
Source/Core/AudioCommon/Src/PulseAudioStream.cpp
View File

@ -22,31 +22,31 @@
#include "PulseAudioStream.h" #include "PulseAudioStream.h"
#define BUFFER_SIZE 4096 namespace
#define BUFFER_SIZE_BYTES (BUFFER_SIZE * 4) {
const size_t BUFFER_SAMPLES = 512;
const size_t CHANNEL_COUNT = 2;
const size_t BUFFER_SIZE = BUFFER_SAMPLES * CHANNEL_COUNT;
}
PulseAudio::PulseAudio(CMixer *mixer) PulseAudio::PulseAudio(CMixer *mixer)
: SoundStream(mixer), thread_running(false), mainloop(NULL) : SoundStream(mixer)
, context(NULL), stream(NULL), iVolume(100) , mix_buffer(BUFFER_SIZE)
{ , thread()
mix_buffer = new u8[BUFFER_SIZE_BYTES]; , run_thread()
} , pa()
{}
PulseAudio::~PulseAudio()
{
delete [] mix_buffer;
}
bool PulseAudio::Start() bool PulseAudio::Start()
{ {
thread_running = true; run_thread = true;
thread = std::thread(std::mem_fun(&PulseAudio::SoundLoop), this); thread = std::thread(std::mem_fun(&PulseAudio::SoundLoop), this);
return true; return true;
} }
void PulseAudio::Stop() void PulseAudio::Stop()
{ {
thread_running = false; run_thread = false;
thread.join(); thread.join();
} }
@ -60,260 +60,54 @@ void PulseAudio::SoundLoop()
{ {
Common::SetCurrentThreadName("Audio thread - pulse"); Common::SetCurrentThreadName("Audio thread - pulse");
thread_running = PulseInit(); if (PulseInit())
while (thread_running)
{ {
int frames_to_deliver = 512; while (run_thread)
m_mixer->Mix((short *)mix_buffer, frames_to_deliver); {
if (!Write(mix_buffer, frames_to_deliver * 4)) m_mixer->Mix(&mix_buffer[0], mix_buffer.size() / CHANNEL_COUNT);
ERROR_LOG(AUDIO, "PulseAudio failure writing data"); Write(&mix_buffer[0], mix_buffer.size() * sizeof(s16));
} }
PulseShutdown(); PulseShutdown();
} }
}
bool PulseAudio::PulseInit() bool PulseAudio::PulseInit()
{ {
// The Sample format to use pa_sample_spec ss = {};
const pa_sample_spec ss = ss.format = PA_SAMPLE_S16LE;
ss.channels = 2;
ss.rate = m_mixer->GetSampleRate();
int error;
pa = pa_simple_new(nullptr, "dolphin-emu", PA_STREAM_PLAYBACK,
nullptr, "audio", &ss, nullptr, nullptr, &error);
if (!pa)
{ {
PA_SAMPLE_S16LE, ERROR_LOG(AUDIO, "PulseAudio failed to initialize: %s",
m_mixer->GetSampleRate(), pa_strerror(error));
2
};
mainloop = pa_threaded_mainloop_new();
context = pa_context_new(pa_threaded_mainloop_get_api(mainloop), "dolphin-emu");
pa_context_set_state_callback(context, ContextStateCB, this);
if (pa_context_connect(context, NULL, PA_CONTEXT_NOFLAGS, NULL) < 0)
{
ERROR_LOG(AUDIO, "PulseAudio failed to connect context: %s",
pa_strerror(pa_context_errno(context)));
return false; return false;
} }
else
pa_threaded_mainloop_lock(mainloop);
pa_threaded_mainloop_start(mainloop);
for (;;)
{ {
pa_context_state_t state;
state = pa_context_get_state(context);
if (state == PA_CONTEXT_READY)
break;
if (!PA_CONTEXT_IS_GOOD(state))
{
ERROR_LOG(AUDIO, "PulseAudio context state failure: %s",
pa_strerror(pa_context_errno(context)));
pa_threaded_mainloop_unlock(mainloop);
return false;
}
// Wait until the context is ready
pa_threaded_mainloop_wait(mainloop);
}
if (!(stream = pa_stream_new(context, "emulator", &ss, NULL)))
{
ERROR_LOG(AUDIO, "PulseAudio failed to create playback stream: %s",
pa_strerror(pa_context_errno(context)));
pa_threaded_mainloop_unlock(mainloop);
return false;
}
// Set callbacks for the playback stream
pa_stream_set_state_callback(stream, StreamStateCB, this);
pa_stream_set_write_callback(stream, StreamWriteCB, this);
if (pa_stream_connect_playback(stream, NULL, NULL, PA_STREAM_NOFLAGS, NULL, NULL) < 0)
{
ERROR_LOG(AUDIO, "PulseAudio failed to connect playback stream: %s",
pa_strerror(pa_context_errno(context)));
pa_threaded_mainloop_unlock(mainloop);
return false;
}
for (;;)
{
pa_stream_state_t state;
state = pa_stream_get_state(stream);
if (state == PA_STREAM_READY)
break;
if (!PA_STREAM_IS_GOOD(state))
{
ERROR_LOG(AUDIO, "PulseAudio stream state failure: %s",
pa_strerror(pa_context_errno(context)));
pa_threaded_mainloop_unlock(mainloop);
return false;
}
// Wait until the stream is ready
pa_threaded_mainloop_wait(mainloop);
}
pa_threaded_mainloop_unlock(mainloop);
SetVolume(iVolume);
NOTICE_LOG(AUDIO, "Pulse successfully initialized."); NOTICE_LOG(AUDIO, "Pulse successfully initialized.");
//SetVolume(iVolume);
return true; return true;
} }
}
void PulseAudio::PulseShutdown() void PulseAudio::PulseShutdown()
{ {
if (mainloop) pa_simple_free(pa);
pa_threaded_mainloop_stop(mainloop); }
if (stream) void PulseAudio::Write(const void *data, size_t length)
pa_stream_unref(stream);
if (context)
{ {
pa_context_disconnect(context); int error;
pa_context_unref(context); if (pa_simple_write(pa, data, length, &error) < 0)
}
if (mainloop)
pa_threaded_mainloop_free(mainloop);
}
void PulseAudio::SignalMainLoop()
{ {
pa_threaded_mainloop_signal(mainloop, 0); ERROR_LOG(AUDIO, "PulseAudio failed to write data: %s",
} pa_strerror(error));
void PulseAudio::ContextStateCB(pa_context *c, void *userdata)
{
switch (pa_context_get_state(c))
{
case PA_CONTEXT_READY:
case PA_CONTEXT_TERMINATED:
case PA_CONTEXT_FAILED:
((PulseAudio *)userdata)->SignalMainLoop();
break;
default:
break;
} }
} }
void PulseAudio::StreamStateCB(pa_stream *s, void * userdata)
{
switch (pa_stream_get_state(s))
{
case PA_STREAM_READY:
case PA_STREAM_TERMINATED:
case PA_STREAM_FAILED:
((PulseAudio *)userdata)->SignalMainLoop();
break;
default:
break;
}
}
void PulseAudio::StreamWriteCB(pa_stream *s, size_t length, void *userdata)
{
((PulseAudio *)userdata)->SignalMainLoop();
}
static bool StateIsGood(pa_context *context, pa_stream *stream)
{
if (!context || !PA_CONTEXT_IS_GOOD(pa_context_get_state(context)) ||
!stream || !PA_STREAM_IS_GOOD(pa_stream_get_state(stream)))
{
if ((context && pa_context_get_state(context) == PA_CONTEXT_FAILED) ||
(stream && pa_stream_get_state(stream) == PA_STREAM_FAILED))
{
ERROR_LOG(AUDIO, "PulseAudio state failure: %s",
pa_strerror(pa_context_errno(context)));
}
else
{
ERROR_LOG(AUDIO, "PulseAudio state failure: %s",
pa_strerror(PA_ERR_BADSTATE));
}
return false;
}
return true;
}
bool PulseAudio::Write(const void *data, size_t length)
{
if (!data || length == 0 || !stream)
return false;
pa_threaded_mainloop_lock(mainloop);
if (!StateIsGood(context, stream))
{
pa_threaded_mainloop_unlock(mainloop);
return false;
}
while (length > 0)
{
size_t l;
int r;
while (!(l = pa_stream_writable_size(stream)))
{
pa_threaded_mainloop_wait(mainloop);
if (!StateIsGood(context, stream))
{
pa_threaded_mainloop_unlock(mainloop);
return false;
}
}
if (l == (size_t)-1)
{
ERROR_LOG(AUDIO, "PulseAudio invalid stream: %s",
pa_strerror(pa_context_errno(context)));
pa_threaded_mainloop_unlock(mainloop);
return false;
}
if (l > length)
l = length;
r = pa_stream_write(stream, data, l, NULL, 0LL, PA_SEEK_RELATIVE);
if (r < 0)
{
ERROR_LOG(AUDIO, "PulseAudio error writing to stream: %s",
pa_strerror(pa_context_errno(context)));
pa_threaded_mainloop_unlock(mainloop);
return false;
}
data = (const uint8_t*) data + l;
length -= l;
}
pa_threaded_mainloop_unlock(mainloop);
return true;
}
void PulseAudio::SetVolume(int volume)
{
iVolume = volume;
if (!stream)
return;
pa_cvolume cvolume;
const pa_channel_map *channels = pa_stream_get_channel_map(stream);
pa_cvolume_set(&cvolume, channels->channels,
iVolume * (PA_VOLUME_NORM - PA_VOLUME_MUTED) / 100);
pa_context_set_sink_input_volume(context, pa_stream_get_index(stream),
&cvolume, NULL, this);
}

23
Source/Core/AudioCommon/Src/PulseAudioStream.h
View File

@ -19,7 +19,8 @@
#define _PULSE_AUDIO_STREAM_H #define _PULSE_AUDIO_STREAM_H
#if defined(HAVE_PULSEAUDIO) && HAVE_PULSEAUDIO #if defined(HAVE_PULSEAUDIO) && HAVE_PULSEAUDIO
#include <pulse/pulseaudio.h> #include <pulse/simple.h>
#include <pulse/error.h>
#endif #endif
#include "Common.h" #include "Common.h"
@ -27,16 +28,16 @@
#include "Thread.h" #include "Thread.h"
#include <vector>
class PulseAudio : public SoundStream class PulseAudio : public SoundStream
{ {
#if defined(HAVE_PULSEAUDIO) && HAVE_PULSEAUDIO #if defined(HAVE_PULSEAUDIO) && HAVE_PULSEAUDIO
public: public:
PulseAudio(CMixer *mixer); PulseAudio(CMixer *mixer);
virtual ~PulseAudio();
virtual bool Start(); virtual bool Start();
virtual void Stop(); virtual void Stop();
virtual void SetVolume(int volume);
static bool isValid() {return true;} static bool isValid() {return true;}
@ -46,22 +47,16 @@ public:
private: private:
virtual void SoundLoop(); virtual void SoundLoop();
bool PulseInit(); bool PulseInit();
void PulseShutdown(); void PulseShutdown();
bool Write(const void *data, size_t bytes); void Write(const void *data, size_t bytes);
void SignalMainLoop();
static void ContextStateCB(pa_context *c, void *userdata);
static void StreamStateCB(pa_stream *s, void * userdata);
static void StreamWriteCB(pa_stream *s, size_t length, void *userdata);
u8 *mix_buffer; std::vector<s16> mix_buffer;
std::thread thread; std::thread thread;
volatile bool thread_running; volatile bool run_thread;
pa_threaded_mainloop *mainloop; pa_simple* pa;
pa_context *context;
pa_stream *stream;
int iVolume;
#else #else
public: public:
PulseAudio(CMixer *mixer) : SoundStream(mixer) {} PulseAudio(CMixer *mixer) : SoundStream(mixer) {}

3
Source/Core/DolphinWX/Src/ConfigMain.cpp
View File

@ -966,8 +966,7 @@ bool CConfigMain::SupportsVolumeChanges(std::string backend)
return (backend == BACKEND_DIRECTSOUND || return (backend == BACKEND_DIRECTSOUND ||
backend == BACKEND_COREAUDIO || backend == BACKEND_COREAUDIO ||
backend == BACKEND_OPENAL || backend == BACKEND_OPENAL ||
backend == BACKEND_XAUDIO2 || backend == BACKEND_XAUDIO2);
backend == BACKEND_PULSEAUDIO);
} }