path: root/extern/audaspace/bindings/C/AUD_Device.cpp

/*******************************************************************************
 * Copyright 2009-2016 Jörg Müller
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 ******************************************************************************/

#include "devices/DeviceManager.h"
#include "devices/I3DDevice.h"
#include "devices/IDeviceFactory.h"
#include "devices/ReadDevice.h"
#include "Exception.h"

#include <cassert>

using namespace aud;

#define AUD_CAPI_IMPLEMENTATION
#include "AUD_Device.h"

static inline aud::Specs convCToSpec(AUD_Specs specs)
{
	aud::Specs s;
	s.channels = static_cast<Channels>(specs.channels);
	s.rate = static_cast<SampleRate>(specs.rate);
	return s;
}

static inline aud::DeviceSpecs convCToDSpec(AUD_DeviceSpecs specs)
{
	aud::DeviceSpecs s;
	s.specs = convCToSpec(specs.specs);
	s.format = static_cast<SampleFormat>(specs.format);
	return s;
}

AUD_API AUD_Device* AUD_Device_open(const char* type, AUD_DeviceSpecs specs, int buffersize, const char* name)
{
	DeviceSpecs dspecs = convCToDSpec(specs);

	if(dspecs.channels == CHANNELS_INVALID)
		dspecs.channels = CHANNELS_STEREO;
	if(dspecs.format == FORMAT_INVALID)
		dspecs.format = FORMAT_FLOAT32;
	if(dspecs.rate == RATE_INVALID)
		dspecs.rate = RATE_48000;
	if(buffersize < 128)
		buffersize = AUD_DEFAULT_BUFFER_SIZE;
	if(name == nullptr)
		name = "";

	try
	{
		if(!type)
		{
			auto device = DeviceManager::getDevice();
			if(!device)
			{
				DeviceManager::openDefaultDevice();
				device = DeviceManager::getDevice();
			}
			return new AUD_Device(device);
		}

		if(type == std::string("read"))
		{
			return new AUD_Device(new ReadDevice(dspecs));
		}

		std::shared_ptr<IDeviceFactory> factory;
		if(!*type)
			factory = DeviceManager::getDefaultDeviceFactory();
		else
			factory = DeviceManager::getDeviceFactory(type);

		if(factory)
		{
			factory->setName(name);
			factory->setSpecs(dspecs);
			factory->setBufferSize(buffersize);
			return new AUD_Device(factory->openDevice());
		}
	}
	catch(Exception&)
	{
	}
	return nullptr;
}

AUD_API void AUD_Device_lock(AUD_Device* device)
{
	auto dev = device ? *device : DeviceManager::getDevice();
	dev->lock();
}

AUD_API AUD_Handle* AUD_Device_play(AUD_Device* device, AUD_Sound* sound, int keep)
{
	assert(sound);
	auto dev = device ? *device : DeviceManager::getDevice();

	try
	{
		AUD_Handle handle = dev->play(*sound, keep);
		if(handle.get())
		{
			return new AUD_Handle(handle);
		}
	}
	catch(Exception&)
	{
	}
	return nullptr;
}

AUD_API void AUD_Device_stopAll(AUD_Device* device)
{
	auto dev = device ? *device : DeviceManager::getDevice();
	dev->stopAll();
}

AUD_API void AUD_Device_unlock(AUD_Device* device)
{
	auto dev = device ? *device : DeviceManager::getDevice();
	dev->unlock();
}

AUD_API AUD_Channels AUD_Device_getChannels(AUD_Device* device)
{
	auto dev = device ? *device : DeviceManager::getDevice();
	return static_cast<AUD_Channels>(dev->getSpecs().channels);
}

AUD_API AUD_DistanceModel AUD_Device_getDistanceModel(AUD_Device* device)
{
	auto dev = device ? std::dynamic_pointer_cast<I3DDevice>(*device) : DeviceManager::get3DDevice();
	return static_cast<AUD_DistanceModel>(dev->getDistanceModel());
}

AUD_API void AUD_Device_setDistanceModel(AUD_Device* device, AUD_DistanceModel value)
{
	auto dev = device ? std::dynamic_pointer_cast<I3DDevice>(*device) : DeviceManager::get3DDevice();
	dev->setDistanceModel(static_cast<DistanceModel>(value));
}

AUD_API float AUD_Device_getDopplerFactor(AUD_Device* device)
{
	auto dev = device ? std::dynamic_pointer_cast<I3DDevice>(*device) : DeviceManager::get3DDevice();
	return dev->getDopplerFactor();
}

AUD_API void AUD_Device_setDopplerFactor(AUD_Device* device, float value)
{
	auto dev = device ? std::dynamic_pointer_cast<I3DDevice>(*device) : DeviceManager::get3DDevice();
	dev->setDopplerFactor(value);
}

AUD_API AUD_SampleFormat AUD_Device_getFormat(AUD_Device* device)
{
	auto dev = device ? *device : DeviceManager::getDevice();
	return static_cast<AUD_SampleFormat>(dev->getSpecs().format);
}

AUD_API void AUD_Device_getListenerLocation(AUD_Device* device, float value[3])
{
	auto dev = device ? std::dynamic_pointer_cast<I3DDevice>(*device) : DeviceManager::get3DDevice();
	Vector3 v = dev->getListenerLocation();
	value[0] = v.x();
	value[1] = v.y();
	value[2] = v.z();
}

AUD_API void AUD_Device_setListenerLocation(AUD_Device* device, const float value[3])
{
	auto dev = device ? std::dynamic_pointer_cast<I3DDevice>(*device) : DeviceManager::get3DDevice();
	Vector3 v(value[0], value[1], value[2]);
	dev->setListenerLocation(v);
}

AUD_API void AUD_Device_getListenerOrientation(AUD_Device* device, float value[4])
{
	auto dev = device ? std::dynamic_pointer_cast<I3DDevice>(*device) : DeviceManager::get3DDevice();
	Quaternion v = dev->getListenerOrientation();
	value[0] = v.x();
	value[1] = v.y();
	value[2] = v.z();
	value[3] = v.w();
}

AUD_API void AUD_Device_setListenerOrientation(AUD_Device* device, const float value[4])
{
	auto dev = device ? std::dynamic_pointer_cast<I3DDevice>(*device) : DeviceManager::get3DDevice();
	Quaternion v(value[3], value[0], value[1], value[2]);
	dev->setListenerOrientation(v);
}

AUD_API void AUD_Device_getListenerVelocity(AUD_Device* device, float value[3])
{
	auto dev = device ? std::dynamic_pointer_cast<I3DDevice>(*device) : DeviceManager::get3DDevice();
	Vector3 v = dev->getListenerVelocity();
	value[0] = v.x();
	value[1] = v.y();
	value[2] = v.z();
}

AUD_API void AUD_Device_setListenerVelocity(AUD_Device* device, const float value[3])
{
	auto dev = device ? std::dynamic_pointer_cast<I3DDevice>(*device) : DeviceManager::get3DDevice();
	Vector3 v(value[0], value[1], value[2]);
	dev->setListenerVelocity(v);
}

AUD_API double AUD_Device_getRate(AUD_Device* device)
{
	auto dev = device ? *device : DeviceManager::getDevice();
	return dev->getSpecs().rate;
}

AUD_API float AUD_Device_getSpeedOfSound(AUD_Device* device)
{
	auto dev = device ? std::dynamic_pointer_cast<I3DDevice>(*device) : DeviceManager::get3DDevice();
	return dev->getSpeedOfSound();
}

AUD_API void AUD_Device_setSpeedOfSound(AUD_Device* device, float value)
{
	auto dev = device ? std::dynamic_pointer_cast<I3DDevice>(*device) : DeviceManager::get3DDevice();
	dev->setSpeedOfSound(value);
}

AUD_API float AUD_Device_getVolume(AUD_Device* device)
{
	auto dev = device ? *device : DeviceManager::getDevice();
	return dev->getVolume();
}

AUD_API void AUD_Device_setVolume(AUD_Device* device, float value)
{
	auto dev = device ? *device : DeviceManager::getDevice();
	dev->setVolume(value);
}

AUD_API int AUD_Device_read(AUD_Device* device, unsigned char* buffer, int length)
{
	assert(device);
	assert(buffer);

	auto readDevice = std::dynamic_pointer_cast<ReadDevice>(*device);
	if(!readDevice)
		return false;

	try
	{
		return readDevice->read(buffer, length);
	}
	catch(Exception&)
	{
		return false;
	}
}

AUD_API void AUD_Device_free(AUD_Device* device)
{
	assert(device);

	try
	{
		delete device;
	}
	catch(Exception&)
	{
	}
}

AUD_API AUD_Device* AUD_Device_getCurrent()
{
	auto device = DeviceManager::getDevice();

	if(!device)
		return nullptr;

	return new AUD_Device(device);
}

AUD_API void AUD_seekSynchronizer(AUD_Handle* handle, double time)
{
	auto synchronizer = DeviceManager::getDevice()->getSynchronizer();
	if(synchronizer)
		synchronizer->seek(*reinterpret_cast<std::shared_ptr<IHandle>*>(handle), time);
}

AUD_API double AUD_getSynchronizerPosition(AUD_Handle* handle)
{
	auto synchronizer = DeviceManager::getDevice()->getSynchronizer();
	if(synchronizer)
		return synchronizer->getPosition(*reinterpret_cast<std::shared_ptr<IHandle>*>(handle));
	return (*reinterpret_cast<std::shared_ptr<IHandle>*>(handle))->getPosition();
}

AUD_API void AUD_playSynchronizer()
{
	auto synchronizer = DeviceManager::getDevice()->getSynchronizer();
	if(synchronizer)
		synchronizer->play();
}

AUD_API void AUD_stopSynchronizer()
{
	auto synchronizer = DeviceManager::getDevice()->getSynchronizer();
	if(synchronizer)
		synchronizer->stop();
}

AUD_API void AUD_setSynchronizerCallback(AUD_syncFunction function, void* data)
{
	auto synchronizer = DeviceManager::getDevice()->getSynchronizer();
	if(synchronizer)
		synchronizer->setSyncCallback(function, data);
}

AUD_API int AUD_isSynchronizerPlaying()
{
	auto synchronizer = DeviceManager::getDevice()->getSynchronizer();
	if(synchronizer)
		return synchronizer->isPlaying();
	return false;
}