1 files changed, 388 insertions, 0 deletions
diff --git a/Src/external_dependencies/openmpt-trunk/mptrack/WineSoundDeviceStub.cpp b/Src/external_dependencies/openmpt-trunk/mptrack/WineSoundDeviceStub.cpp
new file mode 100644
index 00000000..1b434c4e
--- /dev/null
+++ b/Src/external_dependencies/openmpt-trunk/mptrack/WineSoundDeviceStub.cpp
@@ -0,0 +1,388 @@
+/*
+ * WineSoundDeviceStub.cpp
+ * -----------------------
+ * Purpose: Stub sound device driver class connection to WineSupport Wrapper.
+ * Notes  : (currently none)
+ * Authors: OpenMPT Devs
+ * The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
+ */
+
+
+#include "stdafx.h"
+
+#if MPT_COMPILER_MSVC
+#pragma warning(disable:4800) // 'T' : forcing value to bool 'true' or 'false' (performance warning)
+#endif // MPT_COMPILER_MSVC
+
+#include "WineSoundDeviceStub.h"
+
+#include "openmpt/sounddevice/SoundDevice.hpp"
+
+#include "../common/misc_util.h"
+
+#include "MPTrackWine.h"
+#include "wine/NativeSoundDeviceMarshalling.h"
+
+
+
+OPENMPT_NAMESPACE_BEGIN
+
+
+namespace SoundDevice {
+
+
+static mpt::ustring GetTypePrefix()
+{
+	return U_("Wine");
+}
+
+static SoundDevice::Info AddTypePrefix(SoundDevice::Info info)
+{
+	info.type = GetTypePrefix() + U_("-") + info.type;
+	info.apiPath.insert(info.apiPath.begin(), U_("Wine"));
+	return info;
+}
+
+static SoundDevice::Info RemoveTypePrefix(SoundDevice::Info info)
+{
+	info.type = info.type.substr(GetTypePrefix().length() + 1);
+	info.apiPath.erase(info.apiPath.begin());
+	return info;
+}
+
+
+std::vector<SoundDevice::Info> SoundDeviceStub::EnumerateDevices(ILogger &logger, SoundDevice::SysInfo sysInfo)
+{
+	ComponentHandle<ComponentWineWrapper> WineWrapper;
+	if(!IsComponentAvailable(WineWrapper))
+	{
+		return std::vector<SoundDevice::Info>();
+	}
+	MPT_UNREFERENCED_PARAMETER(logger);
+	MPT_UNREFERENCED_PARAMETER(sysInfo); // we do not want to pass this to the native layer because it would actually be totally wrong
+	std::vector<SoundDevice::Info> result = json_cast<std::vector<SoundDevice::Info> >(WineWrapper->SoundDevice_EnumerateDevices());
+	for(auto &info : result)
+	{
+		info = AddTypePrefix(info);
+	}
+	return result;
+}
+
+SoundDeviceStub::SoundDeviceStub(ILogger &logger, SoundDevice::Info info, SoundDevice::SysInfo sysInfo)
+	: impl(nullptr)
+{
+	MPT_UNREFERENCED_PARAMETER(logger);
+	MPT_UNREFERENCED_PARAMETER(sysInfo); // we do not want to pass this to the native layer because it would actually be totally wrong
+	info = RemoveTypePrefix(info);
+	impl = w->OpenMPT_Wine_Wrapper_SoundDevice_Construct(json_cast<std::string>(info).c_str());
+}
+
+SoundDeviceStub::~SoundDeviceStub() {
+	if(impl)
+	{
+		w->OpenMPT_Wine_Wrapper_SoundDevice_Destruct(impl);
+		impl = nullptr;
+	}
+}
+
+static void __cdecl SoundDevice_MessageReceiver_SoundDeviceMessage(void * inst, uintptr_t level, const char * message)
+{
+	SoundDevice::IMessageReceiver * mr = (SoundDevice::IMessageReceiver*)inst;
+	if(!mr)
+	{
+		return;
+	}
+	mr->SoundDeviceMessage((LogLevel)level, mpt::ToUnicode(mpt::Charset::UTF8, message ? message : ""));
+}
+
+void SoundDeviceStub::SetMessageReceiver(SoundDevice::IMessageReceiver *receiver) {
+	OpenMPT_Wine_Wrapper_SoundDevice_IMessageReceiver messageReceiver = {};
+	messageReceiver.inst = receiver;
+	messageReceiver.SoundDeviceMessageFunc = &SoundDevice_MessageReceiver_SoundDeviceMessage;
+	return w->OpenMPT_Wine_Wrapper_SoundDevice_SetMessageReceiver(impl, &messageReceiver);
+}
+
+static void __cdecl SoundCallbackGetReferenceClockNowNanosecondsFunc( void * inst, uint64_t * result ) {
+	SoundDevice::ICallback * callback = ((SoundDevice::ICallback*)inst);
+	if(!callback)
+	{
+		*result = 0;
+		return;
+	}
+	*result = callback->SoundCallbackGetReferenceClockNowNanoseconds();
+}
+static void __cdecl SoundCallbackPreStartFunc( void * inst ) {
+	SoundDevice::ICallback * callback = ((SoundDevice::ICallback*)inst);
+	if(!callback)
+	{
+		return;
+	}
+	callback->SoundCallbackPreStart();
+}
+static void __cdecl SoundCallbackPostStopFunc( void * inst ) {
+	SoundDevice::ICallback * callback = ((SoundDevice::ICallback*)inst);
+	if(!callback)
+	{
+		return;
+	}
+	callback->SoundCallbackPostStop();
+}
+static void __cdecl SoundCallbackIsLockedByCurrentThreadFunc( void * inst, uintptr_t * result ) {
+	SoundDevice::ICallback * callback = ((SoundDevice::ICallback*)inst);
+	if(!callback)
+	{
+		*result = 0;
+		return;
+	}
+	*result = callback->SoundCallbackIsLockedByCurrentThread();
+}
+static void __cdecl SoundCallbackLockFunc( void * inst ) {
+	SoundDevice::ICallback * callback = ((SoundDevice::ICallback*)inst);
+	if(!callback)
+	{
+		return;
+	}
+	callback->SoundCallbackLock();
+}
+static void __cdecl SoundCallbackLockedGetReferenceClockNowNanosecondsFunc( void * inst, uint64_t * result ) {
+	SoundDevice::ICallback * callback = ((SoundDevice::ICallback*)inst);
+	if(!callback)
+	{
+		*result = 0;
+		return;
+	}
+	*result = callback->SoundCallbackLockedGetReferenceClockNowNanoseconds();
+}
+static void __cdecl SoundCallbackLockedProcessPrepareFunc( void * inst, const OpenMPT_SoundDevice_TimeInfo * timeInfo ) {
+	SoundDevice::ICallback * callback = ((SoundDevice::ICallback*)inst);
+	SoundDevice::TimeInfo ti = C::decode(*timeInfo);
+	if(!callback)
+	{
+		return;
+	}
+	callback->SoundCallbackLockedProcessPrepare(ti);
+}
+static void __cdecl SoundCallbackLockedProcessUint8Func( void * inst, const OpenMPT_SoundDevice_BufferFormat * bufferFormat, uintptr_t numFrames, uint8_t * buffer, const uint8_t * inputBuffer ) {
+	SoundDevice::ICallback * callback = ((SoundDevice::ICallback*)inst);
+	SoundDevice::BufferFormat bf = C::decode(*bufferFormat);
+	if(!callback)
+	{
+		return;
+	}
+	callback->SoundCallbackLockedProcess(bf, numFrames, buffer, inputBuffer);
+}
+static void __cdecl SoundCallbackLockedProcessInt8Func( void * inst, const OpenMPT_SoundDevice_BufferFormat * bufferFormat, uintptr_t numFrames, int8_t  * buffer, const int8_t * inputBuffer ) {
+	SoundDevice::ICallback * callback = ((SoundDevice::ICallback*)inst);
+	SoundDevice::BufferFormat bf = C::decode(*bufferFormat);
+	if(!callback)
+	{
+		return;
+	}
+	callback->SoundCallbackLockedProcess(bf, numFrames, buffer, inputBuffer);
+}
+static void __cdecl SoundCallbackLockedProcessInt16Func( void * inst, const OpenMPT_SoundDevice_BufferFormat * bufferFormat, uintptr_t numFrames, int16_t * buffer, const int16_t * inputBuffer ) {
+	SoundDevice::ICallback * callback = ((SoundDevice::ICallback*)inst);
+	SoundDevice::BufferFormat bf = C::decode(*bufferFormat);
+	if(!callback)
+	{
+		return;
+	}
+	callback->SoundCallbackLockedProcess(bf, numFrames, buffer, inputBuffer);
+}
+static void __cdecl SoundCallbackLockedProcessInt24Func( void * inst, const OpenMPT_SoundDevice_BufferFormat * bufferFormat, uintptr_t numFrames, OpenMPT_int24 * buffer, const OpenMPT_int24 * inputBuffer ) {
+	SoundDevice::ICallback * callback = ((SoundDevice::ICallback*)inst);
+	SoundDevice::BufferFormat bf = C::decode(*bufferFormat);
+	if(!callback)
+	{
+		return;
+	}
+	callback->SoundCallbackLockedProcess(bf, numFrames, static_cast<int24*>(buffer), static_cast<const int24*>(inputBuffer));
+}
+static void __cdecl SoundCallbackLockedProcessInt32Func( void * inst, const OpenMPT_SoundDevice_BufferFormat * bufferFormat, uintptr_t numFrames, int32_t * buffer, const int32_t * inputBuffer ) {
+	SoundDevice::ICallback * callback = ((SoundDevice::ICallback*)inst);
+	SoundDevice::BufferFormat bf = C::decode(*bufferFormat);
+	if(!callback)
+	{
+		return;
+	}
+	callback->SoundCallbackLockedProcess(bf, numFrames, buffer, inputBuffer);
+}
+static void __cdecl SoundCallbackLockedProcessFloatFunc( void * inst, const OpenMPT_SoundDevice_BufferFormat * bufferFormat, uintptr_t numFrames, float * buffer, const float * inputBuffer ) {
+	SoundDevice::ICallback * callback = ((SoundDevice::ICallback*)inst);
+	SoundDevice::BufferFormat bf = C::decode(*bufferFormat);
+	if(!callback)
+	{
+		return;
+	}
+	callback->SoundCallbackLockedProcess(bf, numFrames, buffer, inputBuffer);
+}
+static void __cdecl SoundCallbackLockedProcessDoubleFunc( void * inst, const OpenMPT_SoundDevice_BufferFormat * bufferFormat, uintptr_t numFrames, double * buffer, const double * inputBuffer ) {
+	SoundDevice::ICallback * callback = ((SoundDevice::ICallback*)inst);
+	SoundDevice::BufferFormat bf = C::decode(*bufferFormat);
+	if(!callback)
+	{
+		return;
+	}
+	callback->SoundCallbackLockedProcess(bf, numFrames, buffer, inputBuffer);
+}
+static void __cdecl SoundCallbackLockedProcessDoneFunc( void * inst, const OpenMPT_SoundDevice_TimeInfo * timeInfo ) {
+	SoundDevice::ICallback * callback = ((SoundDevice::ICallback*)inst);
+	SoundDevice::TimeInfo ti = C::decode(*timeInfo);
+	if(!callback)
+	{
+		return;
+	}
+	callback->SoundCallbackLockedProcessDone(ti);
+}
+static void __cdecl SoundCallbackUnlockFunc( void * inst ) {
+	SoundDevice::ICallback * callback = ((SoundDevice::ICallback*)inst);
+	if(!callback)
+	{
+		return;
+	}
+	callback->SoundCallbackUnlock();
+}
+
+void SoundDeviceStub::SetCallback(SoundDevice::ICallback *icallback) {
+	OpenMPT_Wine_Wrapper_SoundDevice_ICallback callback = {};
+	callback.inst = icallback;
+	callback.SoundCallbackGetReferenceClockNowNanosecondsFunc = &SoundCallbackGetReferenceClockNowNanosecondsFunc;
+	callback.SoundCallbackPreStartFunc = &SoundCallbackPreStartFunc;
+	callback.SoundCallbackPostStopFunc = &SoundCallbackPostStopFunc;
+	callback.SoundCallbackIsLockedByCurrentThreadFunc = &SoundCallbackIsLockedByCurrentThreadFunc;
+	callback.SoundCallbackLockFunc = &SoundCallbackLockFunc;
+	callback.SoundCallbackLockedGetReferenceClockNowNanosecondsFunc = &SoundCallbackLockedGetReferenceClockNowNanosecondsFunc;
+	callback.SoundCallbackLockedProcessPrepareFunc = &SoundCallbackLockedProcessPrepareFunc;
+	callback.SoundCallbackLockedProcessUint8Func = &SoundCallbackLockedProcessUint8Func;
+	callback.SoundCallbackLockedProcessInt8Func = &SoundCallbackLockedProcessInt8Func;
+	callback.SoundCallbackLockedProcessInt16Func = &SoundCallbackLockedProcessInt16Func;
+	callback.SoundCallbackLockedProcessInt24Func = &SoundCallbackLockedProcessInt24Func;
+	callback.SoundCallbackLockedProcessInt32Func = &SoundCallbackLockedProcessInt32Func;
+	callback.SoundCallbackLockedProcessFloatFunc = &SoundCallbackLockedProcessFloatFunc;
+	callback.SoundCallbackLockedProcessDoubleFunc = &SoundCallbackLockedProcessDoubleFunc;
+	callback.SoundCallbackLockedProcessDoneFunc = &SoundCallbackLockedProcessDoneFunc;
+	callback.SoundCallbackUnlockFunc = &SoundCallbackUnlockFunc;
+	return w->OpenMPT_Wine_Wrapper_SoundDevice_SetCallback(impl, &callback);
+}
+
+SoundDevice::Info SoundDeviceStub::GetDeviceInfo() const {
+	SoundDevice::Info info = json_cast<SoundDevice::Info>(w->result_as_string(w->OpenMPT_Wine_Wrapper_SoundDevice_GetDeviceInfo(impl)));
+	info = AddTypePrefix(info);
+	return info;
+}
+
+SoundDevice::Caps SoundDeviceStub::GetDeviceCaps() const {
+	return json_cast<SoundDevice::Caps>(w->result_as_string(w->OpenMPT_Wine_Wrapper_SoundDevice_GetDeviceCaps(impl)));
+}
+
+SoundDevice::DynamicCaps SoundDeviceStub::GetDeviceDynamicCaps(const std::vector<uint32> &baseSampleRates) {
+	return json_cast<SoundDevice::DynamicCaps>(w->result_as_string(w->OpenMPT_Wine_Wrapper_SoundDevice_GetDeviceDynamicCaps(impl, json_cast<std::string>(baseSampleRates).c_str())));
+}
+
+bool SoundDeviceStub::Init(const SoundDevice::AppInfo &appInfo) {
+	return w->OpenMPT_Wine_Wrapper_SoundDevice_Init(impl, json_cast<std::string>(appInfo).c_str());
+}
+
+bool SoundDeviceStub::Open(const SoundDevice::Settings &settings) {
+	return w->OpenMPT_Wine_Wrapper_SoundDevice_Open(impl, json_cast<std::string>(settings).c_str());
+}
+
+bool SoundDeviceStub::Close() {
+	return w->OpenMPT_Wine_Wrapper_SoundDevice_Close(impl);
+}
+
+bool SoundDeviceStub::Start() {
+	return w->OpenMPT_Wine_Wrapper_SoundDevice_Start(impl);
+}
+
+void SoundDeviceStub::Stop() {
+	return w->OpenMPT_Wine_Wrapper_SoundDevice_Stop(impl);
+}
+
+FlagSet<RequestFlags> SoundDeviceStub::GetRequestFlags() const {
+	uint32_t result = 0;
+	w->OpenMPT_Wine_Wrapper_SoundDevice_GetRequestFlags(impl, &result);
+	return FlagSet<RequestFlags>(result);
+}
+
+bool SoundDeviceStub::IsInited() const {
+	return w->OpenMPT_Wine_Wrapper_SoundDevice_IsInited(impl);
+}
+
+bool SoundDeviceStub::IsOpen() const {
+	return w->OpenMPT_Wine_Wrapper_SoundDevice_IsOpen(impl);
+}
+
+bool SoundDeviceStub::IsAvailable() const {
+	return w->OpenMPT_Wine_Wrapper_SoundDevice_IsAvailable(impl);
+}
+
+bool SoundDeviceStub::IsPlaying() const {
+	return w->OpenMPT_Wine_Wrapper_SoundDevice_IsPlaying(impl);
+}
+
+bool SoundDeviceStub::IsPlayingSilence() const {
+	return w->OpenMPT_Wine_Wrapper_SoundDevice_IsPlayingSilence(impl);
+}
+
+void SoundDeviceStub::StopAndAvoidPlayingSilence() {
+	return w->OpenMPT_Wine_Wrapper_SoundDevice_StopAndAvoidPlayingSilence(impl);
+}
+
+void SoundDeviceStub::EndPlayingSilence() {
+	return w->OpenMPT_Wine_Wrapper_SoundDevice_EndPlayingSilence(impl);
+}
+
+bool SoundDeviceStub::OnIdle() {
+	return w->OpenMPT_Wine_Wrapper_SoundDevice_OnIdle(impl);
+}
+
+SoundDevice::Settings SoundDeviceStub::GetSettings() const {
+	return json_cast<SoundDevice::Settings>(w->result_as_string(w->OpenMPT_Wine_Wrapper_SoundDevice_GetSettings(impl)));
+}
+
+SampleFormat SoundDeviceStub::GetActualSampleFormat() const {
+	int32_t result = 0;
+	w->OpenMPT_Wine_Wrapper_SoundDevice_GetActualSampleFormat(impl, &result);
+	return SampleFormat::FromInt(result);
+}
+
+SoundDevice::BufferAttributes SoundDeviceStub::GetEffectiveBufferAttributes() const {
+	OpenMPT_SoundDevice_BufferAttributes result;
+	w->OpenMPT_Wine_Wrapper_SoundDevice_GetEffectiveBufferAttributes(impl, &result);
+	return C::decode(result);
+}
+
+SoundDevice::TimeInfo SoundDeviceStub::GetTimeInfo() const {
+	OpenMPT_SoundDevice_TimeInfo result;
+	w->OpenMPT_Wine_Wrapper_SoundDevice_GetTimeInfo(impl, &result);
+	return C::decode(result);
+}
+
+SoundDevice::StreamPosition SoundDeviceStub::GetStreamPosition() const {
+	OpenMPT_SoundDevice_StreamPosition result;
+	w->OpenMPT_Wine_Wrapper_SoundDevice_GetStreamPosition(impl, &result);
+	return C::decode(result);
+}
+
+bool SoundDeviceStub::DebugIsFragileDevice() const {
+	return w->OpenMPT_Wine_Wrapper_SoundDevice_DebugIsFragileDevice(impl);
+}
+
+bool SoundDeviceStub::DebugInRealtimeCallback() const {
+	return w->OpenMPT_Wine_Wrapper_SoundDevice_DebugInRealtimeCallback(impl);
+}
+
+SoundDevice::Statistics SoundDeviceStub::GetStatistics() const {
+	return json_cast<SoundDevice::Statistics>(w->result_as_string(w->OpenMPT_Wine_Wrapper_SoundDevice_GetStatistics(impl)));
+}
+
+bool SoundDeviceStub::OpenDriverSettings() {
+	return w->OpenMPT_Wine_Wrapper_SoundDevice_OpenDriverSettings(impl);
+}
+
+
+} // namespace SoundDevice
+
+
+OPENMPT_NAMESPACE_END