winamp/Src/external_dependencies/openmpt-trunk/mptrack/WineSoundDeviceStub.cpp

389 lines
14 KiB
C++
Raw Normal View History

2024-09-24 13:54:57 +01:00
/*
* 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