Add Chromium-only Blender WebEngine parity work

blender-5.2.0/extern/audaspace/bindings/C/AUD_Device.cpp

@@ -0,0 +1,321 @@
+/*******************************************************************************
+ * 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 == double(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(double time)
+{
+	DeviceManager::getDevice()->seekSynchronizer(time);
+}
+
+AUD_API double AUD_getSynchronizerPosition()
+{
+	return DeviceManager::getDevice()->getSynchronizerPosition();
+}
+
+AUD_API void AUD_playSynchronizer()
+{
+	DeviceManager::getDevice()->playSynchronizer();
+}
+
+AUD_API void AUD_stopSynchronizer()
+{
+	DeviceManager::getDevice()->stopSynchronizer();
+}
+
+AUD_API void AUD_setSynchronizerCallback(AUD_syncFunction function, void* data)
+{
+	DeviceManager::getDevice()->setSyncCallback(function, data);
+}
+
+AUD_API int AUD_isSynchronizerPlaying()
+{
+	return DeviceManager::getDevice()->isSynchronizerPlaying();
+}

blender-5.2.0/extern/audaspace/bindings/C/AUD_Device.h

@@ -0,0 +1,258 @@
+/*******************************************************************************
+ * 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.
+ ******************************************************************************/
+
+#pragma once
+
+#include "AUD_Types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// Possible distance models for the 3D device.
+typedef enum
+{
+	AUD_DISTANCE_MODEL_INVALID = 0,
+	AUD_DISTANCE_MODEL_INVERSE,
+	AUD_DISTANCE_MODEL_INVERSE_CLAMPED,
+	AUD_DISTANCE_MODEL_LINEAR,
+	AUD_DISTANCE_MODEL_LINEAR_CLAMPED,
+	AUD_DISTANCE_MODEL_EXPONENT,
+	AUD_DISTANCE_MODEL_EXPONENT_CLAMPED
+} AUD_DistanceModel;
+
+typedef void (*AUD_syncFunction)(void*, int, float);
+
+/**
+ * Opens a new sound device.
+ * \param type       The name of the device.
+ *                   Can be NULL to open the default device with default settings or return the handle to the already opened one.
+ *                   Can be "" to open the a default factory device with given settings.
+ *                   Can be "read" to open a readable device.
+ * \param specs      Specification of the device parameters.
+ * \param buffersize Size of the mixing buffer.
+ * \param name       Custom name of the device.
+ * \return A handle to the opened device or NULL on failure.
+ */
+extern AUD_API AUD_Device* AUD_Device_open(const char* type, AUD_DeviceSpecs specs, int buffersize, const char* name);
+
+/**
+ * Locks the playback device.
+ */
+extern AUD_API void AUD_Device_lock(AUD_Device* device);
+
+/**
+ * Plays back a sound file.
+ * \param sound The handle of the sound file.
+ * \param keep When keep is true the sound source will not be deleted but set to
+ *             paused when its end has been reached.
+ * \return A handle to the played back sound.
+ */
+extern AUD_API AUD_Handle* AUD_Device_play(AUD_Device* device, AUD_Sound* sound, int keep);
+
+/**
+ * Stops all sounds playing.
+ */
+extern AUD_API void AUD_Device_stopAll(AUD_Device* device);
+
+/**
+ * Unlocks the device.
+ */
+extern AUD_API void AUD_Device_unlock(AUD_Device* device);
+
+/**
+ * Retrieves the channels of a device.
+ * param device The device to get the channels from.
+ * return The channels of the device.
+ */
+extern AUD_API AUD_Channels AUD_Device_getChannels(AUD_Device* device);
+
+/**
+ * Retrieves the distance model of a device.
+ * param device The device to get the distance model from.
+ * return The distance model of the device.
+ */
+extern AUD_API AUD_DistanceModel AUD_Device_getDistanceModel(AUD_Device* device);
+
+/**
+ * Sets the distance model of a device.
+ * param device The device to set the distance model from.
+ * param value The new distance model to set.
+ */
+extern AUD_API void AUD_Device_setDistanceModel(AUD_Device* device, AUD_DistanceModel value);
+
+/**
+ * Retrieves the doppler factor of a device.
+ * param device The device to get the doppler factor from.
+ * return The doppler factor of the device.
+ */
+extern AUD_API float AUD_Device_getDopplerFactor(AUD_Device* device);
+
+/**
+ * Sets the doppler factor of a device.
+ * param device The device to set the doppler factor from.
+ * param value The new doppler factor to set.
+ */
+extern AUD_API void AUD_Device_setDopplerFactor(AUD_Device* device, float value);
+
+/**
+ * Retrieves the format of a device.
+ * param device The device to get the format from.
+ * return The format of the device.
+ */
+extern AUD_API AUD_SampleFormat AUD_Device_getFormat(AUD_Device* device);
+
+/**
+ * Retrieves the listener location of a device.
+ * param device The device to get the listener location from.
+ * return The listener location of the device.
+ */
+extern AUD_API void AUD_Device_getListenerLocation(AUD_Device* device, float value[3]);
+
+/**
+ * Sets the listener location of a device.
+ * param device The device to set the listener location from.
+ * param value The new listener location to set.
+ */
+extern AUD_API void AUD_Device_setListenerLocation(AUD_Device* device, const float value[3]);
+
+/**
+ * Retrieves the listener orientation of a device.
+ * param device The device to get the listener orientation from.
+ * return The listener orientation of the device.
+ */
+extern AUD_API void AUD_Device_getListenerOrientation(AUD_Device* device, float value[4]);
+
+/**
+ * Sets the listener orientation of a device.
+ * param device The device to set the listener orientation from.
+ * param value The new listener orientation to set.
+ */
+extern AUD_API void AUD_Device_setListenerOrientation(AUD_Device* device, const float value[4]);
+
+/**
+ * Retrieves the listener velocity of a device.
+ * param device The device to get the listener velocity from.
+ * return The listener velocity of the device.
+ */
+extern AUD_API void AUD_Device_getListenerVelocity(AUD_Device* device, float value[3]);
+
+/**
+ * Sets the listener velocity of a device.
+ * param device The device to set the listener velocity from.
+ * param value The new listener velocity to set.
+ */
+extern AUD_API void AUD_Device_setListenerVelocity(AUD_Device* device, const float value[3]);
+
+/**
+ * Retrieves the rate of a device.
+ * param device The device to get the rate from.
+ * return The rate of the device.
+ */
+extern AUD_API double AUD_Device_getRate(AUD_Device* device);
+
+/**
+ * Retrieves the speed of sound of a device.
+ * param device The device to get the speed of sound from.
+ * return The speed of sound of the device.
+ */
+extern AUD_API float AUD_Device_getSpeedOfSound(AUD_Device* device);
+
+/**
+ * Sets the speed of sound of a device.
+ * param device The device to set the speed of sound from.
+ * param value The new speed of sound to set.
+ */
+extern AUD_API void AUD_Device_setSpeedOfSound(AUD_Device* device, float value);
+
+/**
+ * Retrieves the volume of a device.
+ * param device The device to get the volume from.
+ * return The volume of the device.
+ */
+extern AUD_API float AUD_Device_getVolume(AUD_Device* device);
+
+/**
+ * Sets the volume of a device.
+ * param device The device to set the volume from.
+ * param value The new volume to set.
+ */
+extern AUD_API void AUD_Device_setVolume(AUD_Device* device, float value);
+
+/**
+ * Reads the next samples into the supplied buffer.
+ * \param device The readable device.
+ * \param buffer The target buffer.
+ * \param length The length in samples to be filled.
+ * \return True if the reading succeeded, false if there are no sounds
+ *         played back currently, in that case the buffer is filled with
+ *         silence.
+ */
+extern AUD_API int AUD_Device_read(AUD_Device* device, unsigned char* buffer, int length);
+
+/**
+ * Closes a device. Handle becomes invalid afterwards.
+ * \param device The device to close.
+ */
+extern AUD_API void AUD_Device_free(AUD_Device* device);
+
+/**
+ * Retrieves the current device of the DeviceManager.
+ * \return A pointer to the current device, which needs to be freed with
+ *         AUD_Device_free.
+ */
+extern AUD_API AUD_Device* AUD_Device_getCurrent();
+
+/**
+ * Seeks sequenced sound scene playback.
+ * \param handle Playback handle.
+ * \param time Time in seconds to seek to.
+ */
+extern AUD_API void AUD_seekSynchronizer(double time);
+
+/**
+ * Returns the current sound scene playback time.
+ * \param handle Playback handle.
+ * \return The playback time in seconds.
+ */
+extern AUD_API double AUD_getSynchronizerPosition();
+
+/**
+ * Starts the playback of jack transport if possible.
+ */
+extern AUD_API void AUD_playSynchronizer();
+
+/**
+ * Stops the playback of jack transport if possible.
+ */
+extern AUD_API void AUD_stopSynchronizer();
+
+/**
+ * Sets the sync callback for jack transport.
+ * \param function The callback function.
+ * \param data The data parameter for the callback.
+ */
+extern AUD_API void AUD_setSynchronizerCallback(AUD_syncFunction function, void* data);
+
+/**
+ * Returns whether jack transport is currently playing.
+ * \return Whether jack transport is currently playing.
+ */
+extern AUD_API int AUD_isSynchronizerPlaying();
+
+#ifdef __cplusplus
+}
+#endif

blender-5.2.0/extern/audaspace/bindings/C/AUD_DynamicMusic.cpp

@@ -0,0 +1,144 @@
+/*******************************************************************************
+* Copyright 2015-2016 Juan Francisco Crespo Galán
+*
+* 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 "Exception.h"
+
+#include <cassert>
+
+using namespace aud;
+
+#define AUD_CAPI_IMPLEMENTATION
+#include "AUD_DynamicMusic.h"
+
+AUD_API AUD_DynamicMusic* AUD_DynamicMusic_create(AUD_Device* device)
+{
+	assert(device);
+
+	try
+	{
+		return new AUD_DynamicMusic(new DynamicMusic(*device));
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+}
+
+AUD_API void AUD_DynamicMusic_free(AUD_DynamicMusic* player)
+{
+	assert(player);
+	delete player;
+}
+
+AUD_API int AUD_DynamicMusic_addScene(AUD_DynamicMusic* player, AUD_Sound* scene)
+{
+	assert(player);
+	assert(scene);
+
+	return (*player)->addScene(*scene);
+}
+
+AUD_API int AUD_DynamicMusic_setSecene(AUD_DynamicMusic* player, int scene)
+{
+	assert(player);
+
+	return (*player)->changeScene(scene);
+}
+
+AUD_API int AUD_DynamicMusic_getScene(AUD_DynamicMusic* player)
+{
+	assert(player);
+
+	return (*player)->getScene();
+}
+
+AUD_API int AUD_DynamicMusic_addTransition(AUD_DynamicMusic* player, int ini, int end, AUD_Sound* transition)
+{
+	assert(player);
+	assert(transition);
+
+	return (*player)->addTransition(ini, end, *transition);
+}
+
+AUD_API void AUD_DynamicMusic_setFadeTime(AUD_DynamicMusic* player, float seconds)
+{
+	assert(player);
+
+	(*player)->setFadeTime(seconds);
+}
+
+AUD_API float AUD_DynamicMusic_getFadeTime(AUD_DynamicMusic* player)
+{
+	assert(player);
+
+	return (*player)->getFadeTime();
+}
+
+AUD_API int AUD_DynamicMusic_resume(AUD_DynamicMusic* player)
+{
+	assert(player);
+
+	return (*player)->resume();
+}
+
+AUD_API int AUD_DynamicMusic_pause(AUD_DynamicMusic* player)
+{
+	assert(player);
+
+	return (*player)->pause();
+}
+
+AUD_API int AUD_DynamicMusic_seek(AUD_DynamicMusic* player, double position)
+{
+	assert(player);
+
+	return (*player)->seek(position);
+}
+
+AUD_API double AUD_DynamicMusic_getPosition(AUD_DynamicMusic* player)
+{
+	assert(player);
+
+	return (*player)->getPosition();
+}
+
+AUD_API float AUD_DynamicMusic_getVolume(AUD_DynamicMusic* player)
+{
+	assert(player);
+
+	return (*player)->getVolume();
+}
+
+AUD_API int AUD_DynamicMusic_setVolume(AUD_DynamicMusic* player, float volume)
+{
+	assert(player);
+
+	return (*player)->setVolume(volume);
+}
+
+AUD_API AUD_Status AUD_DynamicMusic_getStatus(AUD_DynamicMusic* player)
+{
+	assert(player);
+
+	return static_cast<AUD_Status>((*player)->getStatus());
+}
+
+AUD_API int AUD_DynamicMusic_stop(AUD_DynamicMusic* player)
+{
+	assert(player);
+
+	return (*player)->stop();
+}

blender-5.2.0/extern/audaspace/bindings/C/AUD_DynamicMusic.h

@@ -0,0 +1,145 @@
+/*******************************************************************************
+* Copyright 2015-2016 Juan Francisco Crespo Galán
+*
+* 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.
+******************************************************************************/
+
+#pragma once
+
+#include "AUD_Types.h"
+#include "AUD_Handle.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+* Creates a new dynamic music player.
+* \param device The device that will be used to play sounds.
+* \return The new DynamicMusic object.
+*/
+extern AUD_API AUD_DynamicMusic* AUD_DynamicMusic_create(AUD_Device* device);
+
+/**
+* Deletes a dynamic music player.
+* \param player The DynamicMusic object to be deleted.
+*/
+extern AUD_API void AUD_DynamicMusic_free(AUD_DynamicMusic* player);
+
+/**
+* Adds a sound scene to a dynamic music player.
+* \param player The DynamicMusic object.
+* \param scene The sound to be added as a scene.
+* \return The index of the new scene.
+*/
+extern AUD_API int AUD_DynamicMusic_addScene(AUD_DynamicMusic* player, AUD_Sound* scene);
+
+/**
+* Changes the current sound scene of a dynamic music player.
+* \param player The DynamicMusic object.
+* \param scene The index of the scene to be played.
+* \return 0 if the target scene doesn't exist.
+*/
+extern AUD_API int AUD_DynamicMusic_setSecene(AUD_DynamicMusic* player, int scene);
+
+/**
+* Retrives the index of the current scene.
+* \param player The DynamicMusic object.
+* \return The index of the current scene.
+*/
+extern AUD_API int AUD_DynamicMusic_getScene(AUD_DynamicMusic* player);
+
+/**
+* Adds a new transition between two scenes.
+* \param player The DynamicMusic object.
+* \param ini The origin scene for the transition.
+* \param end The end scene for the transition.
+* \param transition A sound that will be used as transition between two scenes.
+* \return 0 if the ini or end scenes don't exist.
+*/
+extern AUD_API int AUD_DynamicMusic_addTransition(AUD_DynamicMusic* player, int ini, int end, AUD_Sound* transition);
+
+/**
+* Changes the fade time for the default transitions of a dynamic music player.
+* \param player The DynamicMusic object.
+* \param seconds The amount of secods that the crossfade transition will take.
+*/
+extern AUD_API void AUD_DynamicMusic_setFadeTime(AUD_DynamicMusic* player, float seconds);
+
+/**
+* Retrieves the fade time of a dynamic music player.
+* \param player The DynamicMusic object.
+* \return The fade time of the player.
+*/
+extern AUD_API float AUD_DynamicMusic_getFadeTime(AUD_DynamicMusic* player);
+
+/**
+* Resumes the current scene playback of a dynamic music player if it is paused.
+* \param player The DynamicMusic object.
+* \return 0 if the playback wasn't resumed.
+*/
+extern AUD_API int AUD_DynamicMusic_resume(AUD_DynamicMusic* player);
+
+/**
+* Pauses the current scene of a dynamic music player.
+* \param player The DynamicMusic object.
+* \return 0 if the playback wasn't paused.
+*/
+extern AUD_API int AUD_DynamicMusic_pause(AUD_DynamicMusic* player);
+
+/**
+* Seeks the current playing scene of a dynamic music player.
+* \param player The DynamicMusic object.
+* \param position The new position from which to play back, in seconds.
+* \return 0 if the seeking wasn't possible.
+*/
+extern AUD_API int AUD_DynamicMusic_seek(AUD_DynamicMusic* player, double position);
+
+/**
+* Retrieves the position of the current scene of a dynamic music player.
+* \param player The DynamicMusic object.
+* \return The position of the current playing scene.
+*/
+extern AUD_API double AUD_DynamicMusic_getPosition(AUD_DynamicMusic* player);
+
+/**
+* Retrieves the volume of the current scene of a dynamic music player.
+* \param player The DynamicMusic object.
+* \return The volume of the current playing scene.
+*/
+extern AUD_API float AUD_DynamicMusic_getVolume(AUD_DynamicMusic* player);
+
+/**
+* Changes the volume of the current scene in a dynamic music player.
+* \param player The DynamicMusic object.
+* \param 0 if the volume couldn't be changed.
+*/
+extern AUD_API int AUD_DynamicMusic_setVolume(AUD_DynamicMusic* player, float volume);
+
+/**
+* Retrieves the status of the current scene in a dynamic music player.
+* \param player The DynamicMusic object.
+* \return The Status of the current playing scene.
+*/
+extern AUD_API AUD_Status AUD_DynamicMusic_getStatus(AUD_DynamicMusic* player);
+
+/**
+* Stops the current scene of a dynamic music player.
+* \param player The DynamicMusic object.
+* \return 0 if the playback wasn't stopped.
+*/
+extern AUD_API int AUD_DynamicMusic_stop(AUD_DynamicMusic* player);
+
+#ifdef __cplusplus
+}
+#endif

blender-5.2.0/extern/audaspace/bindings/C/AUD_HRTF.cpp

@@ -0,0 +1,50 @@
+/*******************************************************************************
+* Copyright 2009-2015 Juan Francisco Crespo Galán
+*
+* 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 "Exception.h"
+
+#include <cassert>
+
+using namespace aud;
+
+#define AUD_CAPI_IMPLEMENTATION
+#include "AUD_HRTF.h"
+
+extern AUD_API AUD_HRTF* AUD_HRTF_create()
+{
+	try
+	{
+		return new AUD_HRTF(new HRTF());
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+}
+
+extern AUD_API void AUD_HRTF_free(AUD_HRTF* hrtfs)
+{
+	assert(hrtfs);
+	delete hrtfs;
+}
+
+extern AUD_API void AUD_HRTF_addImpulseResponseFromSound(AUD_HRTF* hrtfs, AUD_Sound* sound, float azimuth, float elevation)
+{
+	assert(hrtfs);
+	assert(sound);
+
+	(*hrtfs)->addImpulseResponse(std::make_shared<StreamBuffer>(*sound), azimuth, elevation);
+}

blender-5.2.0/extern/audaspace/bindings/C/AUD_HRTF.h

@@ -0,0 +1,48 @@
+/*******************************************************************************
+* Copyright 2009-2015 Juan Francisco Crespo Galán
+*
+* 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.
+******************************************************************************/
+
+#pragma once
+
+#include "AUD_Types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+* Creates a new HRTF object.
+* \return The new HRTF object.
+*/
+extern AUD_API AUD_HRTF* AUD_HRTF_create();
+
+/**
+* Deletes a HRTF object.
+* \param hrtfs The HRTF object to be deleted.
+*/
+extern AUD_API void AUD_HRTF_free(AUD_HRTF* hrtfs);
+
+/**
+* Adds a new impulse response to an HRTF object.
+* \param hrtfs The HRTF object.
+* \param sound A Sound object representing an HRTF.
+* \param azimuth The azimuth angle of the HRTF.
+* \param elevation The elevation angle of the HRTF.
+*/
+extern AUD_API void AUD_HRTF_addImpulseResponseFromSound(AUD_HRTF* hrtfs, AUD_Sound* sound, float azimuth, float elevation);
+
+#ifdef __cplusplus
+}
+#endif

blender-5.2.0/extern/audaspace/bindings/C/AUD_Handle.cpp

@@ -0,0 +1,384 @@
+/*******************************************************************************
+ * 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/I3DHandle.h"
+#include "Exception.h"
+
+#include <cassert>
+
+using namespace aud;
+
+#define AUD_CAPI_IMPLEMENTATION
+#include "AUD_Handle.h"
+
+AUD_API int AUD_Handle_pause(AUD_Handle* handle)
+{
+	assert(handle);
+	return (*handle)->pause();
+}
+
+AUD_API int AUD_Handle_resume(AUD_Handle* handle)
+{
+	assert(handle);
+	return (*handle)->resume();
+}
+
+AUD_API int AUD_Handle_stop(AUD_Handle* handle)
+{
+	assert(handle);
+	int result = (*handle)->stop();
+	delete handle;
+	return result;
+}
+
+AUD_API float AUD_Handle_getAttenuation(AUD_Handle* handle)
+{
+	assert(handle);
+	std::shared_ptr<I3DHandle> h = std::dynamic_pointer_cast<I3DHandle>(*handle);
+
+	if(h.get())
+		return h->getAttenuation();
+	return 0.0f;
+}
+
+AUD_API int AUD_Handle_setAttenuation(AUD_Handle* handle, float value)
+{
+	assert(handle);
+	std::shared_ptr<I3DHandle> h = std::dynamic_pointer_cast<I3DHandle>(*handle);
+
+	if(h.get())
+		return h->setAttenuation(value);
+	return false;
+}
+
+AUD_API float AUD_Handle_getConeAngleInner(AUD_Handle* handle)
+{
+	assert(handle);
+	std::shared_ptr<I3DHandle> h = std::dynamic_pointer_cast<I3DHandle>(*handle);
+
+	if(h.get())
+		return h->getConeAngleInner();
+	return 0.0f;
+}
+
+AUD_API int AUD_Handle_setConeAngleInner(AUD_Handle* handle, float value)
+{
+	assert(handle);
+	std::shared_ptr<I3DHandle> h = std::dynamic_pointer_cast<I3DHandle>(*handle);
+
+	if(h.get())
+		return h->setConeAngleInner(value);
+	return false;
+}
+
+AUD_API float AUD_Handle_getConeAngleOuter(AUD_Handle* handle)
+{
+	assert(handle);
+	std::shared_ptr<I3DHandle> h = std::dynamic_pointer_cast<I3DHandle>(*handle);
+
+	if(h.get())
+		return h->getConeAngleOuter();
+	return 0.0f;
+}
+
+AUD_API int AUD_Handle_setConeAngleOuter(AUD_Handle* handle, float value)
+{
+	assert(handle);
+	std::shared_ptr<I3DHandle> h = std::dynamic_pointer_cast<I3DHandle>(*handle);
+
+	if(h.get())
+		return h->setConeAngleOuter(value);
+	return false;
+}
+
+AUD_API float AUD_Handle_getConeVolumeOuter(AUD_Handle* handle)
+{
+	assert(handle);
+	std::shared_ptr<I3DHandle> h = std::dynamic_pointer_cast<I3DHandle>(*handle);
+
+	if(h.get())
+		return h->getConeVolumeOuter();
+	return 0.0f;
+}
+
+AUD_API int AUD_Handle_setConeVolumeOuter(AUD_Handle* handle, float value)
+{
+	assert(handle);
+	std::shared_ptr<I3DHandle> h = std::dynamic_pointer_cast<I3DHandle>(*handle);
+
+	if(h.get())
+		return h->setConeVolumeOuter(value);
+	return false;
+}
+
+AUD_API float AUD_Handle_getDistanceMaximum(AUD_Handle* handle)
+{
+	assert(handle);
+	std::shared_ptr<I3DHandle> h = std::dynamic_pointer_cast<I3DHandle>(*handle);
+
+	if(h.get())
+		return h->getDistanceMaximum();
+	return 0.0f;
+}
+
+AUD_API int AUD_Handle_setDistanceMaximum(AUD_Handle* handle, float value)
+{
+	assert(handle);
+	std::shared_ptr<I3DHandle> h = std::dynamic_pointer_cast<I3DHandle>(*handle);
+
+	if(h.get())
+		return h->setDistanceMaximum(value);
+	return false;
+}
+
+AUD_API float AUD_Handle_getDistanceReference(AUD_Handle* handle)
+{
+	assert(handle);
+	std::shared_ptr<I3DHandle> h = std::dynamic_pointer_cast<I3DHandle>(*handle);
+
+	if(h.get())
+		return h->getDistanceReference();
+	return 0.0f;
+}
+
+AUD_API int AUD_Handle_setDistanceReference(AUD_Handle* handle, float value)
+{
+	assert(handle);
+	std::shared_ptr<I3DHandle> h = std::dynamic_pointer_cast<I3DHandle>(*handle);
+
+	if(h.get())
+		return h->setDistanceReference(value);
+	return false;
+}
+
+AUD_API int AUD_Handle_doesKeep(AUD_Handle* handle)
+{
+	assert(handle);
+	return (*handle)->getKeep();
+}
+
+AUD_API int AUD_Handle_setKeep(AUD_Handle* handle, int value)
+{
+	assert(handle);
+	return (*handle)->setKeep(value);
+}
+
+AUD_API int AUD_Handle_getLocation(AUD_Handle* handle, float value[3])
+{
+	assert(handle);
+	std::shared_ptr<I3DHandle> h = std::dynamic_pointer_cast<I3DHandle>(*handle);
+
+	if(h.get())
+	{
+		Vector3 v = h->getLocation();
+		value[0] = v.x();
+		value[1] = v.y();
+		value[2] = v.z();
+		return true;
+	}
+	return false;
+}
+
+AUD_API int AUD_Handle_setLocation(AUD_Handle* handle, const float value[3])
+{
+	assert(handle);
+	std::shared_ptr<I3DHandle> h = std::dynamic_pointer_cast<I3DHandle>(*handle);
+
+	if(h.get())
+	{
+		Vector3 v = Vector3(value[0], value[1], value[2]);
+		return h->setLocation(v);
+	}
+	return false;
+}
+
+AUD_API int AUD_Handle_getLoopCount(AUD_Handle* handle)
+{
+	assert(handle);
+	return (*handle)->getLoopCount();
+}
+
+AUD_API int AUD_Handle_setLoopCount(AUD_Handle* handle, int value)
+{
+	assert(handle);
+	return (*handle)->setLoopCount(value);
+}
+
+AUD_API int AUD_Handle_getOrientation(AUD_Handle* handle, float value[4])
+{
+	assert(handle);
+	std::shared_ptr<I3DHandle> h = std::dynamic_pointer_cast<I3DHandle>(*handle);
+
+	if(h.get())
+	{
+		Quaternion v = h->getOrientation();
+		value[0] = v.x();
+		value[1] = v.y();
+		value[2] = v.z();
+		value[3] = v.w();
+		return true;
+	}
+	return false;
+}
+
+AUD_API int AUD_Handle_setOrientation(AUD_Handle* handle, const float value[4])
+{
+	assert(handle);
+	std::shared_ptr<I3DHandle> h = std::dynamic_pointer_cast<I3DHandle>(*handle);
+
+	if(h.get())
+	{
+		Quaternion v(value[3], value[0], value[1], value[2]);
+		return h->setOrientation(v);
+	}
+	return false;
+}
+
+AUD_API float AUD_Handle_getPitch(AUD_Handle* handle)
+{
+	assert(handle);
+	return (*handle)->getPitch();
+}
+
+AUD_API int AUD_Handle_setPitch(AUD_Handle* handle, float value)
+{
+	assert(handle);
+	return (*handle)->setPitch(value);
+}
+
+AUD_API double AUD_Handle_getPosition(AUD_Handle* handle)
+{
+	assert(handle);
+	return (*handle)->getPosition();
+}
+
+AUD_API int AUD_Handle_setPosition(AUD_Handle* handle, double value)
+{
+	assert(handle);
+	return (*handle)->seek(value);
+}
+
+AUD_API int AUD_Handle_isRelative(AUD_Handle* handle)
+{
+	assert(handle);
+	std::shared_ptr<I3DHandle> h = std::dynamic_pointer_cast<I3DHandle>(*handle);
+
+	if(h.get())
+		return h->isRelative();
+	return true;
+}
+
+AUD_API int AUD_Handle_setRelative(AUD_Handle* handle, int value)
+{
+	assert(handle);
+	std::shared_ptr<I3DHandle> h = std::dynamic_pointer_cast<I3DHandle>(*handle);
+
+	if(h.get())
+		return h->setRelative(value);
+	return false;
+}
+
+AUD_API AUD_Status AUD_Handle_getStatus(AUD_Handle* handle)
+{
+	assert(handle);
+	return static_cast<AUD_Status>((*handle)->getStatus());
+}
+
+AUD_API int AUD_Handle_getVelocity(AUD_Handle* handle, float value[3])
+{
+	assert(handle);
+	std::shared_ptr<I3DHandle> h = std::dynamic_pointer_cast<I3DHandle>(*handle);
+
+	if(h.get())
+	{
+		Vector3 v = h->getVelocity();
+		value[0] = v.x();
+		value[1] = v.y();
+		value[2] = v.z();
+		return true;
+	}
+	return false;
+}
+
+AUD_API int AUD_Handle_setVelocity(AUD_Handle* handle, const float value[3])
+{
+	assert(handle);
+	std::shared_ptr<I3DHandle> h = std::dynamic_pointer_cast<I3DHandle>(*handle);
+
+	if(h.get())
+	{
+		Vector3 v = Vector3(value[0], value[1], value[2]);
+		return h->setVelocity(v);
+	}
+	return false;
+}
+
+AUD_API float AUD_Handle_getVolume(AUD_Handle* handle)
+{
+	assert(handle);
+	return (*handle)->getVolume();
+}
+
+AUD_API int AUD_Handle_setVolume(AUD_Handle* handle, float value)
+{
+	assert(handle);
+	return (*handle)->setVolume(value);
+}
+
+AUD_API float AUD_Handle_getVolumeMaximum(AUD_Handle* handle)
+{
+	assert(handle);
+	std::shared_ptr<I3DHandle> h = std::dynamic_pointer_cast<I3DHandle>(*handle);
+
+	if(h.get())
+		return h->getVolumeMaximum();
+	return 0.0f;
+}
+
+AUD_API int AUD_Handle_setVolumeMaximum(AUD_Handle* handle, float value)
+{
+	assert(handle);
+	std::shared_ptr<I3DHandle> h = std::dynamic_pointer_cast<I3DHandle>(*handle);
+
+	if(h.get())
+		return h->setVolumeMaximum(value);
+	return false;
+}
+
+AUD_API float AUD_Handle_getVolumeMinimum(AUD_Handle* handle)
+{
+	assert(handle);
+	std::shared_ptr<I3DHandle> h = std::dynamic_pointer_cast<I3DHandle>(*handle);
+
+	if(h.get())
+		return h->getVolumeMinimum();
+	return 0.0f;
+}
+
+AUD_API int AUD_Handle_setVolumeMinimum(AUD_Handle* handle, float value)
+{
+	assert(handle);
+	std::shared_ptr<I3DHandle> h = std::dynamic_pointer_cast<I3DHandle>(*handle);
+
+	if(h.get())
+		return h->setVolumeMinimum(value);
+	return false;
+}
+
+AUD_API void AUD_Handle_free(AUD_Handle* handle)
+{
+	delete handle;
+}

blender-5.2.0/extern/audaspace/bindings/C/AUD_Handle.h

@@ -0,0 +1,308 @@
+/*******************************************************************************
+ * 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.
+ ******************************************************************************/
+
+#pragma once
+
+#include "AUD_Types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// Status of a playback handle.
+typedef enum
+{
+	AUD_STATUS_INVALID = 0,			/// Invalid handle. Maybe due to stopping.
+	AUD_STATUS_PLAYING,				/// Sound is playing.
+	AUD_STATUS_PAUSED,				/// Sound is being paused.
+	AUD_STATUS_STOPPED				/// Sound is stopped but kept in the device.
+} AUD_Status;
+
+/**
+ * Pauses a played back sound.
+ * \param handle The handle to the sound.
+ * \return Whether the handle has been playing or not.
+ */
+extern AUD_API int AUD_Handle_pause(AUD_Handle* handle);
+
+/**
+ * Resumes a paused sound.
+ * \param handle The handle to the sound.
+ * \return Whether the handle has been paused or not.
+ */
+extern AUD_API int AUD_Handle_resume(AUD_Handle* handle);
+
+/**
+ * Stops a playing or paused sound.
+ * \param handle The handle to the sound.
+ * \return Whether the handle has been valid or not.
+ */
+extern AUD_API int AUD_Handle_stop(AUD_Handle* handle);
+
+/**
+ * Retrieves the attenuation of a handle.
+ * param handle The handle to get the attenuation from.
+ * return The attenuation of the handle.
+ */
+extern AUD_API float AUD_Handle_getAttenuation(AUD_Handle* handle);
+
+/**
+ * Sets the attenuation of a handle.
+ * param handle The handle to set the attenuation from.
+ * param value The new attenuation to set.
+ */
+extern AUD_API int AUD_Handle_setAttenuation(AUD_Handle* handle, float value);
+
+/**
+ * Retrieves the cone angle inner of a handle.
+ * param handle The handle to get the cone angle inner from.
+ * return The cone angle inner of the handle.
+ */
+extern AUD_API float AUD_Handle_getConeAngleInner(AUD_Handle* handle);
+
+/**
+ * Sets the cone angle inner of a handle.
+ * param handle The handle to set the cone angle inner from.
+ * param value The new cone angle inner to set.
+ */
+extern AUD_API int AUD_Handle_setConeAngleInner(AUD_Handle* handle, float value);
+
+/**
+ * Retrieves the cone angle outer of a handle.
+ * param handle The handle to get the cone angle outer from.
+ * return The cone angle outer of the handle.
+ */
+extern AUD_API float AUD_Handle_getConeAngleOuter(AUD_Handle* handle);
+
+/**
+ * Sets the cone angle outer of a handle.
+ * param handle The handle to set the cone angle outer from.
+ * param value The new cone angle outer to set.
+ */
+extern AUD_API int AUD_Handle_setConeAngleOuter(AUD_Handle* handle, float value);
+
+/**
+ * Retrieves the cone volume outer of a handle.
+ * param handle The handle to get the cone volume outer from.
+ * return The cone volume outer of the handle.
+ */
+extern AUD_API float AUD_Handle_getConeVolumeOuter(AUD_Handle* handle);
+
+/**
+ * Sets the cone volume outer of a handle.
+ * param handle The handle to set the cone volume outer from.
+ * param value The new cone volume outer to set.
+ */
+extern AUD_API int AUD_Handle_setConeVolumeOuter(AUD_Handle* handle, float value);
+
+/**
+ * Retrieves the distance maximum of a handle.
+ * param handle The handle to get the distance maximum from.
+ * return The distance maximum of the handle.
+ */
+extern AUD_API float AUD_Handle_getDistanceMaximum(AUD_Handle* handle);
+
+/**
+ * Sets the distance maximum of a handle.
+ * param handle The handle to set the distance maximum from.
+ * param value The new distance maximum to set.
+ */
+extern AUD_API int AUD_Handle_setDistanceMaximum(AUD_Handle* handle, float value);
+
+/**
+ * Retrieves the distance reference of a handle.
+ * param handle The handle to get the distance reference from.
+ * return The distance reference of the handle.
+ */
+extern AUD_API float AUD_Handle_getDistanceReference(AUD_Handle* handle);
+
+/**
+ * Sets the distance reference of a handle.
+ * param handle The handle to set the distance reference from.
+ * param value The new distance reference to set.
+ */
+extern AUD_API int AUD_Handle_setDistanceReference(AUD_Handle* handle, float value);
+
+/**
+ * Retrieves the keep of a handle.
+ * param handle The handle to get the keep from.
+ * return The keep of the handle.
+ */
+extern AUD_API int AUD_Handle_doesKeep(AUD_Handle* handle);
+
+/**
+ * Sets the keep of a handle.
+ * param handle The handle to set the keep from.
+ * param value The new keep to set.
+ */
+extern AUD_API int AUD_Handle_setKeep(AUD_Handle* handle, int value);
+
+/**
+ * Retrieves the location of a handle.
+ * param handle The handle to get the location from.
+ * return The location of the handle.
+ */
+extern AUD_API int AUD_Handle_getLocation(AUD_Handle* handle, float value[3]);
+
+/**
+ * Sets the location of a handle.
+ * param handle The handle to set the location from.
+ * param value The new location to set.
+ */
+extern AUD_API int AUD_Handle_setLocation(AUD_Handle* handle, const float value[3]);
+
+/**
+ * Retrieves the loop count of a handle.
+ * param handle The handle to get the loop count from.
+ * return The loop count of the handle.
+ */
+extern AUD_API int AUD_Handle_getLoopCount(AUD_Handle* handle);
+
+/**
+ * Sets the loop count of a handle.
+ * param handle The handle to set the loop count from.
+ * param value The new loop count to set.
+ */
+extern AUD_API int AUD_Handle_setLoopCount(AUD_Handle* handle, int value);
+
+/**
+ * Retrieves the orientation of a handle.
+ * param handle The handle to get the orientation from.
+ * return The orientation of the handle.
+ */
+extern AUD_API int AUD_Handle_getOrientation(AUD_Handle* handle, float value[4]);
+
+/**
+ * Sets the orientation of a handle.
+ * param handle The handle to set the orientation from.
+ * param value The new orientation to set.
+ */
+extern AUD_API int AUD_Handle_setOrientation(AUD_Handle* handle, const float value[4]);
+
+/**
+ * Retrieves the pitch of a handle.
+ * param handle The handle to get the pitch from.
+ * return The pitch of the handle.
+ */
+extern AUD_API float AUD_Handle_getPitch(AUD_Handle* handle);
+
+/**
+ * Sets the pitch of a handle.
+ * param handle The handle to set the pitch from.
+ * param value The new pitch to set.
+ */
+extern AUD_API int AUD_Handle_setPitch(AUD_Handle* handle, float value);
+
+/**
+ * Retrieves the position of a handle.
+ * param handle The handle to get the position from.
+ * return The position of the handle.
+ */
+extern AUD_API double AUD_Handle_getPosition(AUD_Handle* handle);
+
+/**
+ * Sets the position of a handle.
+ * param handle The handle to set the position from.
+ * param value The new position to set.
+ */
+extern AUD_API int AUD_Handle_setPosition(AUD_Handle* handle, double value);
+
+/**
+ * Retrieves the relative of a handle.
+ * param handle The handle to get the relative from.
+ * return The relative of the handle.
+ */
+extern AUD_API int AUD_Handle_isRelative(AUD_Handle* handle);
+
+/**
+ * Sets the relative of a handle.
+ * param handle The handle to set the relative from.
+ * param value The new relative to set.
+ */
+extern AUD_API int AUD_Handle_setRelative(AUD_Handle* handle, int value);
+
+/**
+ * Retrieves the status of a handle.
+ * param handle The handle to get the status from.
+ * return The status of the handle.
+ */
+extern AUD_API AUD_Status AUD_Handle_getStatus(AUD_Handle* handle);
+
+/**
+ * Retrieves the velocity of a handle.
+ * param handle The handle to get the velocity from.
+ * return The velocity of the handle.
+ */
+extern AUD_API int AUD_Handle_getVelocity(AUD_Handle* handle, float value[3]);
+
+/**
+ * Sets the velocity of a handle.
+ * param handle The handle to set the velocity from.
+ * param value The new velocity to set.
+ */
+extern AUD_API int AUD_Handle_setVelocity(AUD_Handle* handle, const float value[3]);
+
+/**
+ * Retrieves the volume of a handle.
+ * param handle The handle to get the volume from.
+ * return The volume of the handle.
+ */
+extern AUD_API float AUD_Handle_getVolume(AUD_Handle* handle);
+
+/**
+ * Sets the volume of a handle.
+ * param handle The handle to set the volume from.
+ * param value The new volume to set.
+ */
+extern AUD_API int AUD_Handle_setVolume(AUD_Handle* handle, float value);
+
+/**
+ * Retrieves the volume maximum of a handle.
+ * param handle The handle to get the volume maximum from.
+ * return The volume maximum of the handle.
+ */
+extern AUD_API float AUD_Handle_getVolumeMaximum(AUD_Handle* handle);
+
+/**
+ * Sets the volume maximum of a handle.
+ * param handle The handle to set the volume maximum from.
+ * param value The new volume maximum to set.
+ */
+extern AUD_API int AUD_Handle_setVolumeMaximum(AUD_Handle* handle, float value);
+
+/**
+ * Retrieves the volume minimum of a handle.
+ * param handle The handle to get the volume minimum from.
+ * return The volume minimum of the handle.
+ */
+extern AUD_API float AUD_Handle_getVolumeMinimum(AUD_Handle* handle);
+
+/**
+ * Sets the volume minimum of a handle.
+ * param handle The handle to set the volume minimum from.
+ * param value The new volume minimum to set.
+ */
+extern AUD_API int AUD_Handle_setVolumeMinimum(AUD_Handle* handle, float value);
+
+/**
+ * Frees a handle.
+ * \param channel Handle to free.
+ */
+extern AUD_API void AUD_Handle_free(AUD_Handle* channel);
+
+#ifdef __cplusplus
+}
+#endif

blender-5.2.0/extern/audaspace/bindings/C/AUD_ImpulseResponse.cpp

@@ -0,0 +1,44 @@
+/*******************************************************************************
+* Copyright 2009-2015 Juan Francisco Crespo Galán
+*
+* 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 "Exception.h"
+
+#include <cassert>
+
+using namespace aud;
+
+#define AUD_CAPI_IMPLEMENTATION
+#include "AUD_ImpulseResponse.h"
+
+AUD_API AUD_ImpulseResponse* AUD_ImpulseResponse_create(AUD_Sound* sound)
+{
+	assert(sound);
+
+	try
+	{
+		return new AUD_ImpulseResponse(new ImpulseResponse(std::make_shared<StreamBuffer>(*sound)));
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+}
+
+AUD_API void AUD_ImpulseResponse_free(AUD_ImpulseResponse* filter)
+{
+	assert(filter);
+	delete filter;
+}

blender-5.2.0/extern/audaspace/bindings/C/AUD_ImpulseResponse.h

@@ -0,0 +1,40 @@
+/*******************************************************************************
+* Copyright 2009-2015 Juan Francisco Crespo Galán
+*
+* 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.
+******************************************************************************/
+
+#pragma once
+
+#include "AUD_Types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+* Creates a new ImpulseResponse object.
+* \param sound A Sound object representing a impulse response.
+* \return The new ImpulseResponse object.
+*/
+extern AUD_API AUD_ImpulseResponse* AUD_ImpulseResponse_create(AUD_Sound* sound);
+
+/**
+* Deletes a ImpulseResponse object.
+* \param threadPool The ImpulseResponse object to be deleted.
+*/
+extern AUD_API void AUD_ImpulseResponse_free(AUD_ImpulseResponse* filter);
+
+#ifdef __cplusplus
+}
+#endif

blender-5.2.0/extern/audaspace/bindings/C/AUD_PlaybackManager.cpp

@@ -0,0 +1,94 @@
+/*******************************************************************************
+* Copyright 2015-2016 Juan Francisco Crespo Galán
+*
+* 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 "Exception.h"
+
+#include <cassert>
+
+using namespace aud;
+
+#define AUD_CAPI_IMPLEMENTATION
+#include "AUD_PlaybackManager.h"
+
+AUD_API AUD_PlaybackManager* AUD_PlaybackManager_create(AUD_Device* device)
+{
+	assert(device);
+
+	try
+	{
+		return new AUD_PlaybackManager(new PlaybackManager(*device));
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+}
+
+AUD_API void AUD_PlaybackManager_free(AUD_PlaybackManager* manager)
+{
+	assert(manager);
+	delete manager;
+}
+
+AUD_API void AUD_PlaybackManager_play(AUD_PlaybackManager* manager, AUD_Sound* sound, unsigned int catKey)
+{
+	assert(manager);
+	assert(sound);
+
+	(*manager)->play(*sound, catKey);
+}
+
+AUD_API int AUD_PlaybackManager_resume(AUD_PlaybackManager* manager, unsigned int catKey)
+{
+	assert(manager);
+	return (*manager)->resume(catKey);
+}
+
+AUD_API int AUD_PlaybackManager_pause(AUD_PlaybackManager* manager, unsigned int catKey)
+{
+	assert(manager);
+	return (*manager)->pause(catKey);
+}
+
+AUD_API unsigned int AUD_PlaybackManager_addCategory(AUD_PlaybackManager* manager, float volume)
+{
+	assert(manager);
+	return (*manager)->addCategory(volume);
+}
+
+AUD_API float AUD_PlaybackManager_getVolume(AUD_PlaybackManager* manager, unsigned int catKey)
+{
+	assert(manager);
+	return (*manager)->getVolume(catKey);
+}
+
+AUD_API int AUD_PlaybackManager_setVolume(AUD_PlaybackManager* manager, float volume, unsigned int catKey)
+{
+	assert(manager);
+	return (*manager)->setVolume(volume, catKey);
+}
+
+AUD_API int AUD_PlaybackManager_stop(AUD_PlaybackManager* manager, unsigned int catKey)
+{
+	assert(manager);
+	return (*manager)->stop(catKey);
+}
+
+AUD_API void AUD_PlaybackManager_clean(AUD_PlaybackManager* manager)
+{
+	assert(manager);
+	(*manager)->clean();
+}

blender-5.2.0/extern/audaspace/bindings/C/AUD_PlaybackManager.h

@@ -0,0 +1,103 @@
+/*******************************************************************************
+* Copyright 2015-2016 Juan Francisco Crespo Galán
+*
+* 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.
+******************************************************************************/
+
+#pragma once
+
+#include "AUD_Types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+* Creates a new PlaybackManager object.
+* \param device The device that will be used to play sounds.
+* \return The new PlaybackManager object.
+*/
+extern AUD_API AUD_PlaybackManager* AUD_PlaybackManager_create(AUD_Device* device);
+
+/**
+* Deletes a PlaybackManager object.
+* \param manager The PlaybackManager object to be deleted.
+*/
+extern AUD_API void AUD_PlaybackManager_free(AUD_PlaybackManager* manager);
+
+/**
+* Plays a sound through the playback manager, adding it into a category.
+* \param manager The PlaybackManager object.
+* \param sound The sound to be played.
+* \param catKey The key of the category into which the sound will be added. If it doesn't exist a new one will be created.
+*/
+extern AUD_API void AUD_PlaybackManager_play(AUD_PlaybackManager* manager, AUD_Sound* sound, unsigned int catKey);
+
+/**
+* Resumes the playback of all the paused sounds assigned to a category of a playback manager.
+* \param manager The PlaybackManager object.
+* \param catKey The key of the category.
+* \return 0 if the category doesn't exist.
+*/
+extern AUD_API int AUD_PlaybackManager_resume(AUD_PlaybackManager* manager, unsigned int catKey);
+
+/**
+* Pauses all the sounds assigned to a category of a playback manager.
+* \param manager The PlaybackManager object.
+* \param catKey The key of the category.
+* \return 0 if the category doesn't exist.
+*/
+extern AUD_API int AUD_PlaybackManager_pause(AUD_PlaybackManager* manager, unsigned int catKey);
+
+/**
+* Adds a new category with a custom volume.
+* \param manager The PlaybackManager object.
+* \param volume The volume value.
+* \return The key of the new category.
+*/
+extern AUD_API unsigned int AUD_PlaybackManager_addCategory(AUD_PlaybackManager* manager, float volume);
+
+/**
+* Retrieves the volume of a category of a playback manager.
+* \param manager The PlaybackManager object.
+* \param catKey The key of the category.
+* \return The volume of the category.
+*/
+extern AUD_API float AUD_PlaybackManager_getVolume(AUD_PlaybackManager* manager, unsigned int catKey);
+
+/**
+* Changes the voulume of a category of a playback manager.
+* \param manager The PlaybackManager object.
+* \param volume The new volume of the category.
+* \param catKey The key of the category.
+* \return 0 if the category doesn't exist.
+*/
+extern AUD_API int AUD_PlaybackManager_setVolume(AUD_PlaybackManager* manager, float volume, unsigned int catKey);
+
+/**
+* Stops all the sounds assigned to a category of a playback manager.
+* \param manager The PlaybackManager object.
+* \param catKey The key of the category.
+* \return 0 if the category doesn't exist.
+*/
+extern AUD_API int AUD_PlaybackManager_stop(AUD_PlaybackManager* manager, unsigned int catKey);
+
+/**
+* Cleans all the invalid handles in a playback manager
+* \param manager The PlaybackManager object.
+*/
+extern AUD_API void AUD_PlaybackManager_clean(AUD_PlaybackManager* manager);
+
+#ifdef __cplusplus
+}
+#endif

blender-5.2.0/extern/audaspace/bindings/C/AUD_Sequence.cpp

@@ -0,0 +1,321 @@
+/*******************************************************************************
+ * 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/I3DDevice.h"
+#include "devices/DeviceManager.h"
+#include "sequence/Sequence.h"
+#include "Exception.h"
+
+#include <cassert>
+
+using namespace aud;
+
+#define AUD_CAPI_IMPLEMENTATION
+#include "AUD_Sequence.h"
+
+AUD_API AUD_Sound* AUD_Sequence_create(float fps, int muted)
+{
+	// specs are changed at a later point!
+	Specs specs;
+	specs.channels = CHANNELS_STEREO;
+	specs.rate = RATE_48000;
+	AUD_Sound* sequence = new AUD_Sound(std::shared_ptr<Sequence>(new Sequence(specs, fps, muted)));
+	return sequence;
+}
+
+AUD_API void AUD_Sequence_free(AUD_Sound* sequence)
+{
+	delete sequence;
+}
+
+AUD_API AUD_SequenceEntry* AUD_Sequence_add(AUD_Sound* sequence, AUD_Sound* sound, double begin, double end, double skip)
+{
+	if(!sound)
+		return new AUD_SequenceEntry(((Sequence *)sequence->get())->add(AUD_Sound(), begin, end, skip));
+	return new AUD_SequenceEntry(((Sequence *)sequence->get())->add(*sound, begin, end, skip));
+}
+
+AUD_API void AUD_Sequence_remove(AUD_Sound* sequence, AUD_SequenceEntry* entry)
+{
+	dynamic_cast<Sequence *>(sequence->get())->remove(*entry);
+	delete entry;
+}
+
+AUD_API void AUD_Sequence_setAnimationData(AUD_Sound* sequence, AUD_AnimateablePropertyType type, int frame, float* data, char animated)
+{
+	AnimateableProperty* prop = dynamic_cast<Sequence *>(sequence->get())->getAnimProperty(static_cast<AnimateablePropertyType>(type));
+	if(animated)
+	{
+		if(frame >= 0)
+		{
+			prop->write(data, frame, 1);
+		}
+	}
+	else
+	{
+		prop->write(data);
+	}
+}
+
+AUD_API AUD_DistanceModel AUD_Sequence_getDistanceModel(AUD_Sound* sequence)
+{
+	assert(sequence);
+	return static_cast<AUD_DistanceModel>(dynamic_cast<Sequence *>(sequence->get())->getDistanceModel());
+}
+
+AUD_API void AUD_Sequence_setDistanceModel(AUD_Sound* sequence, AUD_DistanceModel value)
+{
+	assert(sequence);
+	dynamic_cast<Sequence *>(sequence->get())->setDistanceModel(static_cast<DistanceModel>(value));
+}
+
+AUD_API float AUD_Sequence_getDopplerFactor(AUD_Sound* sequence)
+{
+	assert(sequence);
+	return dynamic_cast<Sequence *>(sequence->get())->getDopplerFactor();
+}
+
+AUD_API void AUD_Sequence_setDopplerFactor(AUD_Sound* sequence, float value)
+{
+	assert(sequence);
+	dynamic_cast<Sequence *>(sequence->get())->setDopplerFactor(value);
+}
+
+AUD_API float AUD_Sequence_getFPS(AUD_Sound* sequence)
+{
+	assert(sequence);
+	return dynamic_cast<Sequence *>(sequence->get())->getFPS();
+}
+
+AUD_API void AUD_Sequence_setFPS(AUD_Sound* sequence, float value)
+{
+	assert(sequence);
+	dynamic_cast<Sequence *>(sequence->get())->setFPS(value);
+}
+
+AUD_API int AUD_Sequence_isMuted(AUD_Sound* sequence)
+{
+	assert(sequence);
+	return dynamic_cast<Sequence *>(sequence->get())->isMuted();
+}
+
+AUD_API void AUD_Sequence_setMuted(AUD_Sound* sequence, int value)
+{
+	assert(sequence);
+	dynamic_cast<Sequence *>(sequence->get())->mute(value);
+}
+
+static inline AUD_Specs convSpecToC(aud::Specs specs)
+{
+	AUD_Specs s;
+	s.channels = static_cast<AUD_Channels>(specs.channels);
+	s.rate = static_cast<AUD_SampleRate>(specs.rate);
+	return s;
+}
+
+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;
+}
+
+AUD_API AUD_Specs AUD_Sequence_getSpecs(AUD_Sound* sequence)
+{
+	assert(sequence);
+	return convSpecToC(dynamic_cast<Sequence *>(sequence->get())->getSpecs());
+}
+
+AUD_API void AUD_Sequence_setSpecs(AUD_Sound* sequence, AUD_Specs value)
+{
+	assert(sequence);
+	dynamic_cast<Sequence *>(sequence->get())->setSpecs(convCToSpec(value));
+}
+
+AUD_API float AUD_Sequence_getSpeedOfSound(AUD_Sound* sequence)
+{
+	assert(sequence);
+	return dynamic_cast<Sequence *>(sequence->get())->getSpeedOfSound();
+}
+
+AUD_API void AUD_Sequence_setSpeedOfSound(AUD_Sound* sequence, float value)
+{
+	assert(sequence);
+	dynamic_cast<Sequence *>(sequence->get())->setSpeedOfSound(value);
+}
+
+
+
+AUD_API void AUD_SequenceEntry_move(AUD_SequenceEntry* entry, double begin, double end, double skip)
+{
+	(*entry)->move(begin, end, skip);
+}
+
+AUD_API void AUD_SequenceEntry_setConstantRangeAnimationData(AUD_SequenceEntry* entry, AUD_AnimateablePropertyType type, int frame_start, int frame_end, float* data)
+{
+	AnimateableProperty* prop = (*entry)->getAnimProperty(static_cast<AnimateablePropertyType>(type));
+	prop->writeConstantRange(data, frame_start, frame_end);
+}
+
+AUD_API void AUD_SequenceEntry_setAnimationData(AUD_SequenceEntry* entry, AUD_AnimateablePropertyType type, int frame, float* data, char animated)
+{
+	AnimateableProperty* prop = (*entry)->getAnimProperty(static_cast<AnimateablePropertyType>(type));
+	if(animated)
+	{
+		if(frame >= 0)
+			prop->write(data, frame, 1);
+	}
+	else
+	{
+		prop->write(data);
+	}
+}
+
+AUD_API float AUD_SequenceEntry_getAttenuation(AUD_SequenceEntry* sequence_entry)
+{
+	assert(sequence_entry);
+	return (*sequence_entry)->getAttenuation();
+}
+
+AUD_API void AUD_SequenceEntry_setAttenuation(AUD_SequenceEntry* sequence_entry, float value)
+{
+	assert(sequence_entry);
+	(*sequence_entry)->setAttenuation(value);
+}
+
+AUD_API float AUD_SequenceEntry_getConeAngleInner(AUD_SequenceEntry* sequence_entry)
+{
+	assert(sequence_entry);
+	return (*sequence_entry)->getConeAngleInner();
+}
+
+AUD_API void AUD_SequenceEntry_setConeAngleInner(AUD_SequenceEntry* sequence_entry, float value)
+{
+	assert(sequence_entry);
+	(*sequence_entry)->setConeAngleInner(value);
+}
+
+AUD_API float AUD_SequenceEntry_getConeAngleOuter(AUD_SequenceEntry* sequence_entry)
+{
+	assert(sequence_entry);
+	return (*sequence_entry)->getConeAngleOuter();
+}
+
+AUD_API void AUD_SequenceEntry_setConeAngleOuter(AUD_SequenceEntry* sequence_entry, float value)
+{
+	assert(sequence_entry);
+	(*sequence_entry)->setConeAngleOuter(value);
+}
+
+AUD_API float AUD_SequenceEntry_getConeVolumeOuter(AUD_SequenceEntry* sequence_entry)
+{
+	assert(sequence_entry);
+	return (*sequence_entry)->getConeVolumeOuter();
+}
+
+AUD_API void AUD_SequenceEntry_setConeVolumeOuter(AUD_SequenceEntry* sequence_entry, float value)
+{
+	assert(sequence_entry);
+	(*sequence_entry)->setConeVolumeOuter(value);
+}
+
+AUD_API float AUD_SequenceEntry_getDistanceMaximum(AUD_SequenceEntry* sequence_entry)
+{
+	assert(sequence_entry);
+	return (*sequence_entry)->getDistanceMaximum();
+}
+
+AUD_API void AUD_SequenceEntry_setDistanceMaximum(AUD_SequenceEntry* sequence_entry, float value)
+{
+	assert(sequence_entry);
+	(*sequence_entry)->setDistanceMaximum(value);
+}
+
+AUD_API float AUD_SequenceEntry_getDistanceReference(AUD_SequenceEntry* sequence_entry)
+{
+	assert(sequence_entry);
+	return (*sequence_entry)->getDistanceReference();
+}
+
+AUD_API void AUD_SequenceEntry_setDistanceReference(AUD_SequenceEntry* sequence_entry, float value)
+{
+	assert(sequence_entry);
+	(*sequence_entry)->setDistanceReference(value);
+}
+
+AUD_API int AUD_SequenceEntry_isMuted(AUD_SequenceEntry* sequence_entry)
+{
+	assert(sequence_entry);
+	return (*sequence_entry)->isMuted();
+}
+
+AUD_API void AUD_SequenceEntry_setMuted(AUD_SequenceEntry* sequence_entry, int value)
+{
+	assert(sequence_entry);
+	(*sequence_entry)->mute(value);
+}
+
+AUD_API int AUD_SequenceEntry_isRelative(AUD_SequenceEntry* sequence_entry)
+{
+	assert(sequence_entry);
+	return (*sequence_entry)->isRelative();
+}
+
+AUD_API void AUD_SequenceEntry_setRelative(AUD_SequenceEntry* sequence_entry, int value)
+{
+	assert(sequence_entry);
+	(*sequence_entry)->setRelative(value);
+}
+
+AUD_API AUD_Sound* AUD_SequenceEntry_getSound(AUD_SequenceEntry* sequence_entry)
+{
+	assert(sequence_entry);
+	return new std::shared_ptr<ISound>((*sequence_entry)->getSound());
+}
+
+AUD_API void AUD_SequenceEntry_setSound(AUD_SequenceEntry* sequence_entry, AUD_Sound* value)
+{
+	assert(sequence_entry);
+	if(value)
+		(*sequence_entry)->setSound(*value);
+	else
+		(*sequence_entry)->setSound(AUD_Sound());
+}
+
+AUD_API float AUD_SequenceEntry_getVolumeMaximum(AUD_SequenceEntry* sequence_entry)
+{
+	assert(sequence_entry);
+	return (*sequence_entry)->getVolumeMaximum();
+}
+
+AUD_API void AUD_SequenceEntry_setVolumeMaximum(AUD_SequenceEntry* sequence_entry, float value)
+{
+	assert(sequence_entry);
+	(*sequence_entry)->setVolumeMaximum(value);
+}
+
+AUD_API float AUD_SequenceEntry_getVolumeMinimum(AUD_SequenceEntry* sequence_entry)
+{
+	assert(sequence_entry);
+	return (*sequence_entry)->getVolumeMinimum();
+}
+
+AUD_API void AUD_SequenceEntry_setVolumeMinimum(AUD_SequenceEntry* sequence_entry, float value)
+{
+	assert(sequence_entry);
+	(*sequence_entry)->setVolumeMinimum(value);
+}

blender-5.2.0/extern/audaspace/bindings/C/AUD_Sequence.h

@@ -0,0 +1,338 @@
+/*******************************************************************************
+ * 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.
+ ******************************************************************************/
+
+#pragma once
+
+#include "AUD_Device.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Creates a new sequenced sound scene.
+ * \param fps The FPS of the scene.
+ * \param muted Whether the scene is muted.
+ * \return The new sound scene.
+ */
+extern AUD_API AUD_Sound* AUD_Sequence_create(float fps, int muted);
+
+/**
+ * Deletes a sound scene.
+ * \param sequence The sound scene.
+ */
+extern AUD_API void AUD_Sequence_free(AUD_Sound* sequence);
+
+/**
+ * Adds a new entry to the scene.
+ * \param sequence The sound scene.
+ * \param sound The sound this entry should play.
+ * \param begin The start time.
+ * \param end The end time or a negative value if determined by the sound.
+ * \param skip How much seconds should be skipped at the beginning.
+ * \return The entry added.
+ */
+extern AUD_API AUD_SequenceEntry* AUD_Sequence_add(AUD_Sound* sequence, AUD_Sound* sound, double begin, double end, double skip);
+
+/**
+ * Removes an entry from the scene.
+ * \param sequence The sound scene.
+ * \param entry The entry to remove.
+ */
+extern AUD_API void AUD_Sequence_remove(AUD_Sound* sequence, AUD_SequenceEntry* entry);
+
+/**
+ * Writes animation data to a sequence.
+ * \param sequence The sound scene.
+ * \param type The type of animation data.
+ * \param frame_start Start of the frame range.
+ * \param frame_end End of the frame range.
+ * \param data The data to write.
+ */
+AUD_API void AUD_SequenceEntry_setConstantRangeAnimationData(AUD_SequenceEntry* entry, AUD_AnimateablePropertyType type, int frame_start, int frame_end, float* data);
+
+/**
+ * Writes animation data to a sequenced entry.
+ * \param entry The sequenced entry.
+ * \param type The type of animation data.
+ * \param frame The frame this data is for.
+ * \param data The data to write.
+ * \param animated Whether the attribute is animated.
+ */
+extern AUD_API void AUD_Sequence_setAnimationData(AUD_Sound* sequence, AUD_AnimateablePropertyType type, int frame, float* data, char animated);
+
+/**
+ * Retrieves the distance model of a sequence.
+ * param sequence The sequence to get the distance model from.
+ * return The distance model of the sequence.
+ */
+extern AUD_API AUD_DistanceModel AUD_Sequence_getDistanceModel(AUD_Sound* sequence);
+
+/**
+ * Sets the distance model of a sequence.
+ * param sequence The sequence to set the distance model from.
+ * param value The new distance model to set.
+ */
+extern AUD_API void AUD_Sequence_setDistanceModel(AUD_Sound* sequence, AUD_DistanceModel value);
+
+/**
+ * Retrieves the doppler factor of a sequence.
+ * param sequence The sequence to get the doppler factor from.
+ * return The doppler factor of the sequence.
+ */
+extern AUD_API float AUD_Sequence_getDopplerFactor(AUD_Sound* sequence);
+
+/**
+ * Sets the doppler factor of a sequence.
+ * param sequence The sequence to set the doppler factor from.
+ * param value The new doppler factor to set.
+ */
+extern AUD_API void AUD_Sequence_setDopplerFactor(AUD_Sound* sequence, float value);
+
+/**
+ * Retrieves the fps of a sequence.
+ * param sequence The sequence to get the fps from.
+ * return The fps of the sequence.
+ */
+extern AUD_API float AUD_Sequence_getFPS(AUD_Sound* sequence);
+
+/**
+ * Sets the fps of a sequence.
+ * param sequence The sequence to set the fps from.
+ * param value The new fps to set.
+ */
+extern AUD_API void AUD_Sequence_setFPS(AUD_Sound* sequence, float value);
+
+/**
+ * Retrieves the muted of a sequence.
+ * param sequence The sequence to get the muted from.
+ * return The muted of the sequence.
+ */
+extern AUD_API int AUD_Sequence_isMuted(AUD_Sound* sequence);
+
+/**
+ * Sets the muted of a sequence.
+ * param sequence The sequence to set the muted from.
+ * param value The new muted to set.
+ */
+extern AUD_API void AUD_Sequence_setMuted(AUD_Sound* sequence, int value);
+
+/**
+ * Retrieves the specs of a sequence.
+ * param sequence The sequence to get the specs from.
+ * return The specs of the sequence.
+ */
+extern AUD_API AUD_Specs AUD_Sequence_getSpecs(AUD_Sound* sequence);
+
+/**
+ * Sets the specs of a sequence.
+ * param sequence The sequence to set the specs from.
+ * param value The new specs to set.
+ */
+extern AUD_API void AUD_Sequence_setSpecs(AUD_Sound* sequence, AUD_Specs value);
+
+/**
+ * Retrieves the speed of sound of a sequence.
+ * param sequence The sequence to get the speed of sound from.
+ * return The speed of sound of the sequence.
+ */
+extern AUD_API float AUD_Sequence_getSpeedOfSound(AUD_Sound* sequence);
+
+/**
+ * Sets the speed of sound of a sequence.
+ * param sequence The sequence to set the speed of sound from.
+ * param value The new speed of sound to set.
+ */
+extern AUD_API void AUD_Sequence_setSpeedOfSound(AUD_Sound* sequence, float value);
+
+
+
+/**
+ * Moves the entry.
+ * \param entry The sequenced entry.
+ * \param begin The new start time.
+ * \param end The new end time or a negative value if unknown.
+ * \param skip How many seconds to skip at the beginning.
+ */
+extern AUD_API void AUD_SequenceEntry_move(AUD_SequenceEntry* entry, double begin, double end, double skip);
+
+/**
+ * Writes animation data to a sequenced entry.
+ * \param entry The sequenced entry.
+ * \param type The type of animation data.
+ * \param frame The frame this data is for.
+ * \param data The data to write.
+ * \param animated Whether the attribute is animated.
+ */
+extern AUD_API void AUD_SequenceEntry_setAnimationData(AUD_SequenceEntry* entry, AUD_AnimateablePropertyType type, int frame, float* data, char animated);
+
+/**
+ * Retrieves the attenuation of a sequence_entry.
+ * param sequence_entry The sequence_entry to get the attenuation from.
+ * return The attenuation of the sequence_entry.
+ */
+extern AUD_API float AUD_SequenceEntry_getAttenuation(AUD_SequenceEntry* sequence_entry);
+
+/**
+ * Sets the attenuation of a sequence_entry.
+ * param sequence_entry The sequence_entry to set the attenuation from.
+ * param value The new attenuation to set.
+ */
+extern AUD_API void AUD_SequenceEntry_setAttenuation(AUD_SequenceEntry* sequence_entry, float value);
+
+/**
+ * Retrieves the cone angle inner of a sequence_entry.
+ * param sequence_entry The sequence_entry to get the cone angle inner from.
+ * return The cone angle inner of the sequence_entry.
+ */
+extern AUD_API float AUD_SequenceEntry_getConeAngleInner(AUD_SequenceEntry* sequence_entry);
+
+/**
+ * Sets the cone angle inner of a sequence_entry.
+ * param sequence_entry The sequence_entry to set the cone angle inner from.
+ * param value The new cone angle inner to set.
+ */
+extern AUD_API void AUD_SequenceEntry_setConeAngleInner(AUD_SequenceEntry* sequence_entry, float value);
+
+/**
+ * Retrieves the cone angle outer of a sequence_entry.
+ * param sequence_entry The sequence_entry to get the cone angle outer from.
+ * return The cone angle outer of the sequence_entry.
+ */
+extern AUD_API float AUD_SequenceEntry_getConeAngleOuter(AUD_SequenceEntry* sequence_entry);
+
+/**
+ * Sets the cone angle outer of a sequence_entry.
+ * param sequence_entry The sequence_entry to set the cone angle outer from.
+ * param value The new cone angle outer to set.
+ */
+extern AUD_API void AUD_SequenceEntry_setConeAngleOuter(AUD_SequenceEntry* sequence_entry, float value);
+
+/**
+ * Retrieves the cone volume outer of a sequence_entry.
+ * param sequence_entry The sequence_entry to get the cone volume outer from.
+ * return The cone volume outer of the sequence_entry.
+ */
+extern AUD_API float AUD_SequenceEntry_getConeVolumeOuter(AUD_SequenceEntry* sequence_entry);
+
+/**
+ * Sets the cone volume outer of a sequence_entry.
+ * param sequence_entry The sequence_entry to set the cone volume outer from.
+ * param value The new cone volume outer to set.
+ */
+extern AUD_API void AUD_SequenceEntry_setConeVolumeOuter(AUD_SequenceEntry* sequence_entry, float value);
+
+/**
+ * Retrieves the distance maximum of a sequence_entry.
+ * param sequence_entry The sequence_entry to get the distance maximum from.
+ * return The distance maximum of the sequence_entry.
+ */
+extern AUD_API float AUD_SequenceEntry_getDistanceMaximum(AUD_SequenceEntry* sequence_entry);
+
+/**
+ * Sets the distance maximum of a sequence_entry.
+ * param sequence_entry The sequence_entry to set the distance maximum from.
+ * param value The new distance maximum to set.
+ */
+extern AUD_API void AUD_SequenceEntry_setDistanceMaximum(AUD_SequenceEntry* sequence_entry, float value);
+
+/**
+ * Retrieves the distance reference of a sequence_entry.
+ * param sequence_entry The sequence_entry to get the distance reference from.
+ * return The distance reference of the sequence_entry.
+ */
+extern AUD_API float AUD_SequenceEntry_getDistanceReference(AUD_SequenceEntry* sequence_entry);
+
+/**
+ * Sets the distance reference of a sequence_entry.
+ * param sequence_entry The sequence_entry to set the distance reference from.
+ * param value The new distance reference to set.
+ */
+extern AUD_API void AUD_SequenceEntry_setDistanceReference(AUD_SequenceEntry* sequence_entry, float value);
+
+/**
+ * Retrieves the muted of a sequence_entry.
+ * param sequence_entry The sequence_entry to get the muted from.
+ * return The muted of the sequence_entry.
+ */
+extern AUD_API int AUD_SequenceEntry_isMuted(AUD_SequenceEntry* sequence_entry);
+
+/**
+ * Sets the muted of a sequence_entry.
+ * param sequence_entry The sequence_entry to set the muted from.
+ * param value The new muted to set.
+ */
+extern AUD_API void AUD_SequenceEntry_setMuted(AUD_SequenceEntry* sequence_entry, int value);
+
+/**
+ * Retrieves the relative of a sequence_entry.
+ * param sequence_entry The sequence_entry to get the relative from.
+ * return The relative of the sequence_entry.
+ */
+extern AUD_API int AUD_SequenceEntry_isRelative(AUD_SequenceEntry* sequence_entry);
+
+/**
+ * Sets the relative of a sequence_entry.
+ * param sequence_entry The sequence_entry to set the relative from.
+ * param value The new relative to set.
+ */
+extern AUD_API void AUD_SequenceEntry_setRelative(AUD_SequenceEntry* sequence_entry, int value);
+
+/**
+ * Retrieves the sound of a sequence_entry.
+ * param sequence_entry The sequence_entry to get the sound from.
+ * return The sound of the sequence_entry.
+ */
+extern AUD_API AUD_Sound* AUD_SequenceEntry_getSound(AUD_SequenceEntry* sequence_entry);
+
+/**
+ * Sets the sound of a sequence_entry.
+ * param sequence_entry The sequence_entry to set the sound from.
+ * param value The new sound to set.
+ */
+extern AUD_API void AUD_SequenceEntry_setSound(AUD_SequenceEntry* sequence_entry, AUD_Sound* value);
+
+/**
+ * Retrieves the volume maximum of a sequence_entry.
+ * param sequence_entry The sequence_entry to get the volume maximum from.
+ * return The volume maximum of the sequence_entry.
+ */
+extern AUD_API float AUD_SequenceEntry_getVolumeMaximum(AUD_SequenceEntry* sequence_entry);
+
+/**
+ * Sets the volume maximum of a sequence_entry.
+ * param sequence_entry The sequence_entry to set the volume maximum from.
+ * param value The new volume maximum to set.
+ */
+extern AUD_API void AUD_SequenceEntry_setVolumeMaximum(AUD_SequenceEntry* sequence_entry, float value);
+
+/**
+ * Retrieves the volume minimum of a sequence_entry.
+ * param sequence_entry The sequence_entry to get the volume minimum from.
+ * return The volume minimum of the sequence_entry.
+ */
+extern AUD_API float AUD_SequenceEntry_getVolumeMinimum(AUD_SequenceEntry* sequence_entry);
+
+/**
+ * Sets the volume minimum of a sequence_entry.
+ * param sequence_entry The sequence_entry to set the volume minimum from.
+ * param value The new volume minimum to set.
+ */
+extern AUD_API void AUD_SequenceEntry_setVolumeMinimum(AUD_SequenceEntry* sequence_entry, float value);
+
+#ifdef __cplusplus
+}
+#endif

blender-5.2.0/extern/audaspace/bindings/C/AUD_Sound.cpp

@@ -0,0 +1,880 @@
+/*******************************************************************************
+ * 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 "generator/Sawtooth.h"
+#include "generator/Sine.h"
+#include "generator/Silence.h"
+#include "generator/Square.h"
+#include "generator/Triangle.h"
+#include "file/File.h"
+#include "file/FileWriter.h"
+#include "util/StreamBuffer.h"
+#include "fx/Accumulator.h"
+#include "fx/ADSR.h"
+#include "fx/Delay.h"
+#include "fx/Envelope.h"
+#include "fx/Fader.h"
+#include "fx/Highpass.h"
+#include "fx/IIRFilter.h"
+#include "fx/Limiter.h"
+#include "fx/Loop.h"
+#include "fx/Lowpass.h"
+#include "fx/Modulator.h"
+#include "fx/Pitch.h"
+#include "fx/Reverse.h"
+#include "fx/Sum.h"
+#include "fx/Threshold.h"
+#include "fx/Volume.h"
+#include "fx/SoundList.h"
+#include "fx/MutableSound.h"
+#include "sequence/Double.h"
+#include "sequence/Superpose.h"
+#include "sequence/PingPong.h"
+#include "respec/LinearResample.h"
+#include "respec/JOSResample.h"
+#include "respec/JOSResampleReader.h"
+#include "respec/ChannelMapper.h"
+#include "respec/ChannelMapperReader.h"
+#include "util/Buffer.h"
+#include "Exception.h"
+
+#include "fx/Echo.h"
+
+#ifdef WITH_CONVOLUTION
+#include "fx/BinauralSound.h"
+#include "fx/ConvolverSound.h"
+#include "fx/Equalizer.h"
+#endif
+
+#ifdef WITH_RUBBERBAND
+#include "fx/TimeStretchPitchScale.h"
+#include "fx/AnimateableTimeStretchPitchScale.h"
+#endif
+
+#include <cassert>
+#include <cstring>
+
+using namespace aud;
+
+#define AUD_CAPI_IMPLEMENTATION
+#include "AUD_Sound.h"
+
+static inline AUD_Specs convSpecToC(aud::Specs specs)
+{
+	AUD_Specs s;
+	s.channels = static_cast<AUD_Channels>(specs.channels);
+	s.rate = static_cast<AUD_SampleRate>(specs.rate);
+	return s;
+}
+
+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;
+}
+
+AUD_API AUD_Specs AUD_Sound_getSpecs(AUD_Sound* sound)
+{
+	assert(sound);
+
+	return convSpecToC((*sound)->createReader()->getSpecs());
+}
+
+AUD_API int AUD_Sound_getLength(AUD_Sound* sound)
+{
+	assert(sound);
+
+	return (*sound)->createReader()->getLength();
+}
+
+AUD_API int AUD_Sound_getFileStreams(AUD_Sound* sound, AUD_StreamInfo **stream_infos)
+{
+	assert(sound);
+
+	std::shared_ptr<File> file = std::dynamic_pointer_cast<File>(*sound);
+
+	if(file)
+	{
+		try
+		{
+			auto streams = file->queryStreams();
+
+			size_t size = sizeof(AUD_StreamInfo) * streams.size();
+
+			if(!size)
+			{
+				*stream_infos = nullptr;
+				return 0;
+			}
+
+			*stream_infos = reinterpret_cast<AUD_StreamInfo*>(std::malloc(size));
+			std::memcpy(*stream_infos, streams.data(), size);
+
+			return streams.size();
+		}
+		catch(Exception&)
+		{
+		}
+	}
+
+	*stream_infos = nullptr;
+	return 0;
+}
+
+AUD_API sample_t* AUD_Sound_data(AUD_Sound* sound, int* length, AUD_Specs* specs)
+{
+	assert(sound);
+	assert(length);
+	assert(specs);
+
+	auto stream_buffer = std::dynamic_pointer_cast<StreamBuffer>(*sound);
+	if(!stream_buffer)
+		stream_buffer = std::make_shared<StreamBuffer>(*sound);
+	*specs = convSpecToC(stream_buffer->getSpecs());
+	auto buffer = stream_buffer->getBuffer();
+
+	*length = buffer->getSize() / AUD_SAMPLE_SIZE((*specs));
+
+	sample_t* data = new sample_t[buffer->getSize()];
+
+	std::memcpy(data, buffer->getBuffer(), buffer->getSize());
+
+	return data;
+}
+
+AUD_API void AUD_Sound_freeData(sample_t* data)
+{
+	delete[] data;
+}
+
+AUD_API const char* AUD_Sound_write(AUD_Sound* sound, const char* filename, AUD_SampleRate rate, AUD_Channels channels, AUD_SampleFormat format, AUD_Container container, AUD_Codec codec, int bitrate, int buffersize)
+{
+	assert(sound);
+	assert(filename);
+
+	try
+	{
+		std::shared_ptr<IReader> reader = (*sound)->createReader();
+
+		DeviceSpecs specs;
+		specs.specs = reader->getSpecs();
+
+		if((rate != double(RATE_INVALID)) && (specs.rate != rate))
+		{
+			specs.rate = rate;
+			reader = std::make_shared<JOSResampleReader>(reader, rate);
+		}
+
+		if((channels != AUD_CHANNELS_INVALID) && (specs.channels != static_cast<Channels>(channels)))
+		{
+			specs.channels = static_cast<Channels>(channels);
+			reader = std::make_shared<ChannelMapperReader>(reader, specs.channels);
+		}
+
+		if(format == AUD_FORMAT_INVALID)
+			format = AUD_FORMAT_S16;
+		specs.format = static_cast<SampleFormat>(format);
+
+		const char* invalid_container_error = "Container could not be determined from filename.";
+
+		if(container == AUD_CONTAINER_INVALID)
+		{
+			std::string path = filename;
+
+			if(path.length() < 4)
+				return invalid_container_error;
+
+			std::string extension = path.substr(path.length() - 4);
+
+			if(extension == ".ac3")
+				container = AUD_CONTAINER_AC3;
+			else if(extension == "flac")
+				container = AUD_CONTAINER_FLAC;
+			else if(extension == ".mkv")
+				container = AUD_CONTAINER_MATROSKA;
+			else if(extension == ".mp2")
+				container = AUD_CONTAINER_MP2;
+			else if(extension == ".mp3")
+				container = AUD_CONTAINER_MP3;
+			else if(extension == ".ogg")
+				container = AUD_CONTAINER_OGG;
+			else if(extension == ".wav")
+				container = AUD_CONTAINER_WAV;
+			else if(extension == ".aac")
+				container = AUD_CONTAINER_AAC;
+			else
+				return invalid_container_error;
+		}
+
+		if(codec == AUD_CODEC_INVALID)
+		{
+			switch(container)
+			{
+			case AUD_CONTAINER_AC3:
+				codec = AUD_CODEC_AC3;
+				break;
+			case AUD_CONTAINER_FLAC:
+				codec = AUD_CODEC_FLAC;
+				break;
+			case AUD_CONTAINER_MATROSKA:
+				codec = AUD_CODEC_OPUS;
+				break;
+			case AUD_CONTAINER_MP2:
+				codec = AUD_CODEC_MP2;
+				break;
+			case AUD_CONTAINER_MP3:
+				codec = AUD_CODEC_MP3;
+				break;
+			case AUD_CONTAINER_OGG:
+				codec = AUD_CODEC_VORBIS;
+				break;
+			case AUD_CONTAINER_WAV:
+				codec = AUD_CODEC_PCM;
+				break;
+			case AUD_CONTAINER_AAC:
+				codec = AUD_CODEC_AAC;
+				break;
+			default:
+				return "Unknown container, cannot select default codec.";
+			}
+		}
+
+		if(buffersize <= 0)
+			buffersize = AUD_DEFAULT_BUFFER_SIZE;
+
+		std::shared_ptr<IWriter> writer = FileWriter::createWriter(filename, specs, static_cast<Container>(container), static_cast<Codec>(codec), bitrate);
+		FileWriter::writeReader(reader, writer, 0, buffersize);
+	}
+	catch(Exception&)
+	{
+		return "An exception occured while writing.";
+	}
+
+	return nullptr;
+}
+
+AUD_API AUD_Sound* AUD_Sound_buffer(sample_t* data, int length, AUD_Specs specs)
+{
+	assert(data);
+
+	if(length <= 0 || specs.rate <= 0 || specs.channels <= 0)
+	{
+		return nullptr;
+	}
+
+	int size = length * AUD_SAMPLE_SIZE(specs);
+
+	std::shared_ptr<Buffer> buffer = std::make_shared<Buffer>(size);
+
+	std::memcpy(buffer->getBuffer(), data, size);
+
+	try
+	{
+		return new AUD_Sound(new StreamBuffer(buffer, convCToSpec(specs)));
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+}
+
+AUD_API AUD_Sound* AUD_Sound_bufferFile(unsigned char* buffer, int size)
+{
+	assert(buffer);
+	return new AUD_Sound(new File(buffer, size));
+}
+
+AUD_API AUD_Sound* AUD_Sound_bufferFileStream(unsigned char* buffer, int size, int stream)
+{
+	assert(buffer);
+	return new AUD_Sound(new File(buffer, size, stream));
+}
+
+AUD_API AUD_Sound* AUD_Sound_cache(AUD_Sound* sound)
+{
+	assert(sound);
+
+	try
+	{
+		return new AUD_Sound(new StreamBuffer(*sound));
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+}
+
+AUD_API AUD_Sound* AUD_Sound_file(const char* filename)
+{
+	assert(filename);
+	return new AUD_Sound(new File(filename));
+}
+
+AUD_API AUD_Sound* AUD_Sound_fileStream(const char* filename, int stream)
+{
+	assert(filename);
+	return new AUD_Sound(new File(filename, stream));
+}
+
+AUD_API AUD_Sound* AUD_Sound_sawtooth(float frequency, AUD_SampleRate rate)
+{
+	return new AUD_Sound(new Sawtooth(frequency, rate));
+}
+
+AUD_API AUD_Sound* AUD_Sound_silence(AUD_SampleRate rate)
+{
+	return new AUD_Sound(new Silence(rate));
+}
+
+AUD_API AUD_Sound* AUD_Sound_sine(float frequency, AUD_SampleRate rate)
+{
+	return new AUD_Sound(new Sine(frequency, rate));
+}
+
+AUD_API AUD_Sound* AUD_Sound_square(float frequency, AUD_SampleRate rate)
+{
+	return new AUD_Sound(new Square(frequency, rate));
+}
+
+AUD_API AUD_Sound* AUD_Sound_triangle(float frequency, AUD_SampleRate rate)
+{
+	return new AUD_Sound(new Triangle(frequency, rate));
+}
+
+AUD_API AUD_Sound* AUD_Sound_accumulate(AUD_Sound* sound, int additive)
+{
+	assert(sound);
+
+	try
+	{
+		return new AUD_Sound(new Accumulator(*sound, additive));
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+}
+
+AUD_API AUD_Sound* AUD_Sound_ADSR(AUD_Sound* sound, float attack, float decay, float sustain, float release)
+{
+	assert(sound);
+
+	try
+	{
+		return new AUD_Sound(new ADSR(*sound, attack, decay, sustain, release));
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+}
+
+AUD_API AUD_Sound* AUD_Sound_delay(AUD_Sound* sound, float delay)
+{
+	assert(sound);
+
+	try
+	{
+		return new AUD_Sound(new Delay(*sound, delay));
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+}
+
+AUD_API AUD_Sound* AUD_Sound_envelope(AUD_Sound* sound, float attack, float release, float threshold, float arthreshold)
+{
+	assert(sound);
+
+	try
+	{
+		return new AUD_Sound(new Envelope(*sound, attack, release, threshold, arthreshold));
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+}
+
+AUD_API AUD_Sound* AUD_Sound_fadein(AUD_Sound* sound, float start, float length)
+{
+	assert(sound);
+
+	try
+	{
+		return new AUD_Sound(new Fader(*sound, FADE_IN, start, length));
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+}
+
+AUD_API AUD_Sound* AUD_Sound_fadeout(AUD_Sound* sound, float start, float length)
+{
+	assert(sound);
+
+	try
+	{
+		return new AUD_Sound(new Fader(*sound, FADE_OUT, start, length));
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+}
+
+AUD_API AUD_Sound* AUD_Sound_filter(AUD_Sound* sound, float* b, int b_length, float* a, int a_length)
+{
+	assert(sound);
+
+	try
+	{
+		std::vector<float> a_coeff, b_coeff;
+
+		if(b)
+			for(int i = 0; i < b_length; i++)
+				b_coeff.push_back(b[i]);
+
+		if(a)
+		{
+			for(int i = 0; i < a_length; i++)
+				a_coeff.push_back(a[i]);
+
+			if(*a == 0.0f)
+				a_coeff[0] = 1.0f;
+		}
+
+		return new AUD_Sound(new IIRFilter(*sound, b_coeff, a_coeff));
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+}
+
+AUD_API AUD_Sound* AUD_Sound_highpass(AUD_Sound* sound, float frequency, float Q)
+{
+	assert(sound);
+
+	try
+	{
+		return new AUD_Sound(new Highpass(*sound, frequency, Q));
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+}
+
+AUD_API AUD_Sound* AUD_Sound_limit(AUD_Sound* sound, float start, float end)
+{
+	assert(sound);
+
+	try
+	{
+		return new AUD_Sound(new Limiter(*sound, start, end));
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+}
+
+AUD_API AUD_Sound* AUD_Sound_loop(AUD_Sound* sound, int count)
+{
+	assert(sound);
+
+	try
+	{
+		return new AUD_Sound(new Loop(*sound, count));
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+}
+
+AUD_API AUD_Sound* AUD_Sound_lowpass(AUD_Sound* sound, float frequency, float Q)
+{
+	assert(sound);
+
+	try
+	{
+		return new AUD_Sound(new Lowpass(*sound, frequency, Q));
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+}
+
+AUD_API AUD_Sound* AUD_Sound_modulate(AUD_Sound* first, AUD_Sound* second)
+{
+	assert(first);
+	assert(second);
+
+	try
+	{
+		return new AUD_Sound(new Modulator(*first, *second));
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+}
+
+AUD_API AUD_Sound* AUD_Sound_pitch(AUD_Sound* sound, float factor)
+{
+	assert(sound);
+
+	try
+	{
+		return new AUD_Sound(new Pitch(*sound, factor));
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+}
+
+AUD_API AUD_Sound* AUD_Sound_rechannel(AUD_Sound* sound, AUD_Channels channels)
+{
+	assert(sound);
+
+	try
+	{
+		DeviceSpecs specs;
+		specs.channels = static_cast<Channels>(channels);
+		specs.rate = RATE_INVALID;
+		specs.format = FORMAT_INVALID;
+		return new AUD_Sound(new ChannelMapper(*sound, specs));
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+}
+
+AUD_API AUD_Sound* AUD_Sound_resample(AUD_Sound* sound, AUD_SampleRate rate, AUD_ResampleQuality quality)
+{
+	assert(sound);
+
+	try
+	{
+		DeviceSpecs specs;
+		specs.channels = CHANNELS_INVALID;
+		specs.rate = rate;
+		specs.format = FORMAT_INVALID;
+		if (quality == AUD_RESAMPLE_QUALITY_FASTEST)
+		{
+			return new AUD_Sound(new LinearResample(*sound, specs));
+		}
+		else
+		{
+			return new AUD_Sound(new JOSResample(*sound, specs, static_cast<ResampleQuality>(quality)));
+		}
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+}
+
+AUD_API AUD_Sound* AUD_Sound_reverse(AUD_Sound* sound)
+{
+	assert(sound);
+
+	try
+	{
+		return new AUD_Sound(new Reverse(*sound));
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+}
+
+AUD_API AUD_Sound* AUD_Sound_sum(AUD_Sound* sound)
+{
+	assert(sound);
+
+	try
+	{
+		return new AUD_Sound(new Sum(*sound));
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+}
+
+AUD_API AUD_Sound* AUD_Sound_threshold(AUD_Sound* sound, float threshold)
+{
+	assert(sound);
+
+	try
+	{
+		return new AUD_Sound(new Threshold(*sound, threshold));
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+}
+
+AUD_API AUD_Sound* AUD_Sound_volume(AUD_Sound* sound, float volume)
+{
+	assert(sound);
+
+	try
+	{
+		return new AUD_Sound(new Volume(*sound, volume));
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+}
+
+AUD_API AUD_Sound* AUD_Sound_join(AUD_Sound* first, AUD_Sound* second)
+{
+	assert(first);
+	assert(second);
+
+	try
+	{
+		return new AUD_Sound(new Double(*first, *second));
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+}
+
+AUD_API AUD_Sound* AUD_Sound_mix(AUD_Sound* first, AUD_Sound* second)
+{
+	assert(first);
+	assert(second);
+
+	try
+	{
+		return new AUD_Sound(new Superpose(*first, *second));
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+}
+
+AUD_API AUD_Sound* AUD_Sound_pingpong(AUD_Sound* sound)
+{
+	assert(sound);
+
+	try
+	{
+		return new AUD_Sound(new PingPong(*sound));
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+}
+
+AUD_API void AUD_Sound_free(AUD_Sound* sound)
+{
+	assert(sound);
+	delete sound;
+}
+
+AUD_API AUD_Sound* AUD_Sound_copy(AUD_Sound* sound)
+{
+	return new std::shared_ptr<ISound>(*sound);
+}
+
+AUD_API AUD_Sound* AUD_Sound_list(int random)
+{
+	try
+	{
+		return new AUD_Sound(new SoundList(random));
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+}
+
+AUD_API int AUD_SoundList_addSound(AUD_Sound* list, AUD_Sound* sound)
+{
+	assert(sound);
+	assert(list);
+
+	std::shared_ptr<SoundList> s = std::dynamic_pointer_cast<SoundList>(*list);
+	if(s.get())
+	{
+		s->addSound(*sound);
+		return 1;
+	}
+	else
+		return 0;
+
+}
+
+AUD_API AUD_Sound* AUD_Sound_mutable(AUD_Sound* sound)
+{
+	assert(sound);
+
+	try
+	{
+		return new AUD_Sound(new MutableSound(*sound));
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+}
+
+#ifdef WITH_CONVOLUTION
+
+AUD_API AUD_Sound* AUD_Sound_Convolver(AUD_Sound* sound, AUD_ImpulseResponse* filter, AUD_ThreadPool* threadPool)
+{
+	assert(sound);
+	assert(filter);
+	assert(threadPool);
+
+	try
+	{
+		return new AUD_Sound(new ConvolverSound(*sound, *filter, *threadPool));
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+}
+
+AUD_API AUD_Sound* AUD_Sound_Binaural(AUD_Sound* sound, AUD_HRTF* hrtfs, AUD_Source* source, AUD_ThreadPool* threadPool)
+{
+	assert(sound);
+	assert(hrtfs);
+	assert(source);
+	assert(threadPool);
+
+	try
+	{
+		return new AUD_Sound(new BinauralSound(*sound, *hrtfs, *source, *threadPool));
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+}
+#endif
+
+AUD_API AUD_Sound* AUD_Sound_Echo(AUD_Sound* sound, float delay, float feedback, float mix, bool resetBuffer)
+{
+	assert(sound);
+	try
+	{
+		return new AUD_Sound(new Echo(*sound, delay, feedback, mix, resetBuffer));
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+}
+
+#ifdef WITH_CONVOLUTION
+AUD_API AUD_Sound* AUD_Sound_equalize(AUD_Sound* sound, float *definition, int size, float maxFreqEq, int sizeConversion)
+{
+	assert(sound);
+
+	std::shared_ptr<Buffer> buf = std::shared_ptr<Buffer>(new Buffer(sizeof(float)*size));
+	std::memcpy(buf->getBuffer(), definition, sizeof(float)*size);
+	AUD_Sound *equalizer=new AUD_Sound(new Equalizer(*sound, buf, size, maxFreqEq, sizeConversion));
+	return equalizer;
+}
+#endif
+
+#ifdef WITH_RUBBERBAND
+AUD_API AUD_Sound* AUD_Sound_timeStretchPitchScale(AUD_Sound* sound, double timeRatio, double pitchScale, AUD_StretcherQuality quality, char preserveFormant)
+{
+	assert(sound);
+	try
+	{
+		return new AUD_Sound(new TimeStretchPitchScale(*sound, timeRatio, pitchScale, static_cast<StretcherQuality>(quality), preserveFormant));
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+}
+
+AUD_API AUD_Sound* AUD_Sound_animateableTimeStretchPitchScale(AUD_Sound* sound, float fps, double timeRatio, double pitchScale, AUD_StretcherQuality quality, char preserveFormant)
+{
+	assert(sound);
+	try
+	{
+		return new AUD_Sound(new AnimateableTimeStretchPitchScale(*sound, fps, timeRatio, pitchScale, static_cast<StretcherQuality>(quality), preserveFormant));
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+}
+
+AUD_API void AUD_Sound_animateableTimeStretchPitchScale_setConstantRangeAnimationData(AUD_Sound* sound, AUD_AnimateablePropertyType type, int frame_start, int frame_end,
+                                                                                      float* data)
+{
+	std::shared_ptr<AnimateableProperty> prop = std::dynamic_pointer_cast<AnimateableTimeStretchPitchScale>(*sound)->getAnimProperty(static_cast<AnimateablePropertyType>(type));
+	prop->writeConstantRange(data, frame_start, frame_end);
+}
+
+AUD_API void AUD_Sound_animateableTimeStretchPitchScale_setAnimationData(AUD_Sound* sound, AUD_AnimateablePropertyType type, int frame, float* data, char animated)
+{
+	std::shared_ptr<AnimateableProperty> prop = std::dynamic_pointer_cast<AnimateableTimeStretchPitchScale>(*sound)->getAnimProperty(static_cast<AnimateablePropertyType>(type));
+	if(animated)
+	{
+		if(frame >= 0)
+			prop->write(data, frame, 1);
+	}
+	else
+	{
+		prop->write(data);
+	}
+}
+
+AUD_API float AUD_Sound_animateableTimeStretchPitchScale_getFPS(AUD_Sound* sound)
+{
+	assert(sound);
+	return dynamic_cast<AnimateableTimeStretchPitchScale*>(sound->get())->getFPS();
+}
+
+AUD_API void AUD_Sound_animateableTimeStretchPitchScale_setFPS(AUD_Sound* sound, float value)
+{
+	assert(sound);
+	dynamic_cast<AnimateableTimeStretchPitchScale*>(sound->get())->setFPS(value);
+}
+
+AUD_API bool AUD_Sound_isAnimateableTimeStretchPitchScale(AUD_Sound* sound)
+{
+	assert(sound);
+	return dynamic_cast<AnimateableTimeStretchPitchScale*>(sound->get()) != nullptr;
+}
+
+#endif

blender-5.2.0/extern/audaspace/bindings/C/AUD_Sound.h

@@ -0,0 +1,491 @@
+/*******************************************************************************
+ * 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.
+ ******************************************************************************/
+
+#pragma once
+
+#include "AUD_Types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Retrieves the sample specification of the sound.
+ * \param sound The sound to retrieve from.
+ * \return The sample specification of the sound.
+ * \note This function creates a reader from the sound and deletes it again.
+ */
+extern AUD_API AUD_Specs AUD_Sound_getSpecs(AUD_Sound* sound);
+
+/**
+ * Retrieves the approximate length of the sound.
+ * \param sound The sound to retrieve from.
+ * \return The length of the sound in samples.
+ * \note This function creates a reader from the sound and deletes it again.
+ */
+extern AUD_API int AUD_Sound_getLength(AUD_Sound* sound);
+
+/**
+ * Retrieves the stream infos of a sound file.
+ * \param sound The sound to retrieve from which must be a file sound.
+ * \param infos A pointer to a AUD_StreamInfo array that will be allocated and must afterwards be freed by the caller.
+ * \return The number of items in the infos array.
+ */
+extern AUD_API int AUD_Sound_getFileStreams(AUD_Sound* sound, AUD_StreamInfo** stream_infos);
+
+/**
+ * Reads a sound's samples into memory.
+ * \param sound The sound to read.
+ * \param length Pointer to store the length of memory read.
+ * \param specs Pointer to store the data's sample specification.
+ * \return A pointer to the sample data.
+ * \warning The data has to be freed with AUD_Sound_freeData.
+ */
+extern AUD_API sample_t* AUD_Sound_data(AUD_Sound* sound, int* length, AUD_Specs* specs);
+
+/**
+ * Frees a buffer previously allocated with AUD_Sound_data.
+ * \param data The buffer to be freed.
+ */
+extern AUD_API void AUD_Sound_freeData(sample_t* data);
+
+/**
+ * Writes the sound to a file.
+ * \param sound The sound to write.
+ * \param filename The path to write to..
+ * \param rate The sample rate to write with.
+ * \param channels The number of channels to write with.
+ * \param format The sample format to write with.
+ * \param container The container format for the file.
+ * \param codec The codec to use in the file.
+ * \param bitrate The bitrate to write with.
+ * \param buffersize The size of the writing buffer.
+ * \return A nullptr or an error message in case of error.
+ * \note Most parameters can be set to zero for default values.
+ */
+extern AUD_API const char* AUD_Sound_write(AUD_Sound* sound, const char* filename, AUD_SampleRate rate, AUD_Channels channels, AUD_SampleFormat format, AUD_Container container, AUD_Codec codec, int bitrate, int buffersize);
+
+/**
+ * Creates a sound from a data buffer.
+ * \param data The data as interleaved samples.
+ * \param length The data's length in samples.
+ * \param specs The data's sample specification.
+ * \return A handle of the sound.
+ * \note The data gets copied to an internal memory buffer.
+ *       The pointer does not need to stay valid for the lifetime of the object.
+ */
+extern AUD_API AUD_Sound* AUD_Sound_buffer(sample_t* data, int length, AUD_Specs specs);
+
+/**
+ * Loads a sound file from a memory buffer.
+ * \param buffer The buffer which contains the sound file.
+ * \param size The size of the buffer.
+ * \return A handle of the sound file.
+ */
+extern AUD_API AUD_Sound* AUD_Sound_bufferFile(unsigned char* buffer, int size);
+
+/**
+ * Loads a sound file from a memory buffer.
+ * \param buffer The buffer which contains the sound file.
+ * \param size The size of the buffer.
+ * \param stream The index of the audio stream within the file if it contains multiple audio streams.
+ * \return A handle of the sound file.
+ */
+extern AUD_API AUD_Sound* AUD_Sound_bufferFileStream(unsigned char* buffer, int size, int stream);
+
+/**
+ * Caches a sound into a memory buffer.
+ * \param sound The sound to cache.
+ * \return A handle of the cached sound.
+ */
+extern AUD_API AUD_Sound* AUD_Sound_cache(AUD_Sound* sound);
+
+/**
+ * Loads a sound file.
+ * \param filename The filename of the sound file.
+ * \return A handle of the sound file.
+ */
+extern AUD_API AUD_Sound* AUD_Sound_file(const char* filename);
+
+/**
+ * Loads a sound file.
+ * \param filename The filename of the sound file.
+ * \param stream The index of the audio stream within the file if it contains multiple audio streams.
+ * \return A handle of the sound file.
+ */
+extern AUD_API AUD_Sound* AUD_Sound_fileStream(const char* filename, int stream);
+
+/**
+ * Creates a sawtooth sound.
+ * \param frequency The frequency of the generated sawtooth sound.
+ * \param rate The sample rate of the sawtooth sound.
+ * \return A handle of the sound.
+ */
+extern AUD_API AUD_Sound* AUD_Sound_sawtooth(float frequency, AUD_SampleRate rate);
+
+/**
+ * Creates a quiet sound.
+ * \param rate The sample rate of the silence sound.
+ * \return A handle of the sound.
+ */
+extern AUD_API AUD_Sound* AUD_Sound_silence(AUD_SampleRate rate);
+
+/**
+ * Creates a sine sound.
+ * \param frequency The frequency of the generated sine sound.
+ * \param rate The sample rate of the sine sound.
+ * \return A handle of the sound.
+ */
+extern AUD_API AUD_Sound* AUD_Sound_sine(float frequency, AUD_SampleRate rate);
+
+/**
+ * Creates a square sound.
+ * \param frequency The frequency of the generated square sound.
+ * \param rate The sample rate of the square sound.
+ * \return A handle of the sound.
+ */
+extern AUD_API AUD_Sound* AUD_Sound_square(float frequency, AUD_SampleRate rate);
+
+/**
+ * Creates a triangle sound.
+ * \param frequency The frequency of the generated triangle sound.
+ * \param rate The sample rate of the triangle sound.
+ * \return A handle of the sound.
+ */
+extern AUD_API AUD_Sound* AUD_Sound_triangle(float frequency, AUD_SampleRate rate);
+
+/**
+ * Accumulates a sound by summing over positive input differences thus generating a monotonic sigal.
+ * If additivity is set to true negative input differences get added too, but positive ones with a factor of two.
+ * Note that with additivity the signal is not monotonic anymore.
+ * \param sound The sound to accumulate.
+ * \param additive Whether the accumulation should be additive or not.
+ * \return A handle of the accumulated sound.
+ */
+extern AUD_API AUD_Sound* AUD_Sound_accumulate(AUD_Sound* sound, int additive);
+
+/**
+ * Attack-Decay-Sustain-Release envelopes the volume of a sound.
+ * Note: there is currently no way to trigger the release with this API.
+ * \param sound The sound to filter.
+ * \param attack The attack time in seconds.
+ * \param decay The decay time in seconds.
+ * \param sustain The sustain level.
+ * \param release The release time in seconds.
+ * \return A handle of the filtered sound.
+ */
+extern AUD_API AUD_Sound* AUD_Sound_ADSR(AUD_Sound* sound, float attack, float decay, float sustain, float release);
+
+/**
+ * Delays a sound.
+ * \param sound The sound to dealy.
+ * \param delay The delay in seconds.
+ * \return A handle of the delayed sound.
+ */
+extern AUD_API AUD_Sound* AUD_Sound_delay(AUD_Sound* sound, float delay);
+
+/**
+ * Envelopes a sound.
+ * \param sound The sound to envelope.
+ * \param attack The attack factor.
+ * \param release The release factor.
+ * \param threshold The general threshold value.
+ * \param arthreshold The attack/release threshold value.
+ * \return A handle of the enveloped sound.
+ */
+extern AUD_API AUD_Sound* AUD_Sound_envelope(AUD_Sound* sound, float attack, float release, float threshold, float arthreshold);
+
+/**
+ * Fade in a sound.
+ * \param sound The sound to be fade in.
+ * \param start The time when the fading should start in seconds.
+ * \param length The duration of the fade in seconds.
+ * \return A handle of the faded sound.
+ */
+extern AUD_API AUD_Sound* AUD_Sound_fadein(AUD_Sound* sound, float start, float length);
+
+/**
+ * Fade out a sound.
+ * \param sound The sound to be fade out.
+ * \param start The time when the fading should start in seconds.
+ * \param length The duration of the fade in seconds.
+ * \return A handle of the faded sound.
+ */
+extern AUD_API AUD_Sound* AUD_Sound_fadeout(AUD_Sound* sound, float start, float length);
+
+/**
+ * Filter a sound.
+ * \param sound The sound to be filtered.
+ * \param b The nominator filter coefficients, may be NULL.
+ * \param b_length The length of the b array.
+ * \param a The denominator filter coefficients, may be NULL.
+ * \param a_length The length of the a array.
+ * \return A handle of the filtered sound.
+ */
+extern AUD_API AUD_Sound* AUD_Sound_filter(AUD_Sound* sound, float* b, int b_length, float* a, int a_length);
+
+/**
+ * Highpass filters a sound.
+ * \param sound The sound to filter.
+ * \param frequency The filter cut-off frequency.
+ * \param Q The filter quality. If usunsure which value to use, pass 1.0f.
+ * \return A handle of the filtered sound.
+ */
+extern AUD_API AUD_Sound* AUD_Sound_highpass(AUD_Sound* sound, float frequency, float Q);
+
+/**
+ * Limits a sound.
+ * \param sound The sound to limit.
+ * \param start The start time in seconds.
+ * \param end The stop time in seconds.
+ * \return A handle of the limited sound.
+ */
+extern AUD_API AUD_Sound* AUD_Sound_limit(AUD_Sound* sound, float start, float end);
+
+/**
+ * Loops a sound.
+ * \param sound The sound to loop.
+ * \param count How often the sound should be looped. Negative values mean endlessly.
+ * \return A handle of the looped sound.
+ */
+extern AUD_API AUD_Sound* AUD_Sound_loop(AUD_Sound* sound, int count);
+
+/**
+ * Lowpass filters a sound.
+ * \param sound The sound to filter.
+ * \param frequency The filter cut-off frequency.
+ * \param Q The filter quality. If usunsure which value to use, pass 1.0f.
+ * \return A handle of the filtered sound.
+ */
+extern AUD_API AUD_Sound* AUD_Sound_lowpass(AUD_Sound* sound, float frequency, float Q);
+
+/**
+ * Modulates two sound, which means multiplying the sound samples.
+ * \param first The first sound.
+ * \param second The second sound.
+ * \return A handle of the modulated sound.
+ */
+extern AUD_API AUD_Sound* AUD_Sound_modulate(AUD_Sound* first, AUD_Sound* second);
+
+/**
+ * Changes the pitch of a sound.
+ * \param sound The sound to change.
+ * \param factor The factor to change the pitch with.
+ * \return A handle of the pitched sound.
+ */
+extern AUD_API AUD_Sound* AUD_Sound_pitch(AUD_Sound* sound, float factor);
+
+/**
+ * Rechannels the sound.
+ * \param sound The sound to rechannel.
+ * \param channels The new channel configuration.
+ * \return The rechanneled sound.
+ */
+extern AUD_API AUD_Sound* AUD_Sound_rechannel(AUD_Sound* sound, AUD_Channels channels);
+
+/**
+ * Resamples the sound.
+ * \param sound The sound to resample.
+ * \param rate The new sample rate.
+ * \param quality Resampling quality vs performance choice.
+ * \return The resampled sound.
+ */
+extern AUD_API AUD_Sound* AUD_Sound_resample(AUD_Sound* sound, AUD_SampleRate rate, AUD_ResampleQuality quality);
+
+/**
+ * Reverses a sound. Make sure the sound source can be reversed.
+ * \param sound The sound to reverse.
+ * \return A handle of the reversed sound.
+ */
+extern AUD_API AUD_Sound* AUD_Sound_reverse(AUD_Sound* sound);
+
+/**
+ * Sums the samples of a sound.
+ * \param sound The sound to sum.
+ * \return A handle of the summed sound.
+ */
+extern AUD_API AUD_Sound* AUD_Sound_sum(AUD_Sound* sound);
+
+/**
+ * Turns a sound into a square wave by thresholding.
+ * \param sound The sound to threshold.
+ * \param threshold Threshold value over which an amplitude counts non-zero.
+ * \return A handle of the thresholded sound.
+ */
+extern AUD_API AUD_Sound* AUD_Sound_threshold(AUD_Sound* sound, float threshold);
+
+/**
+ * Changes the volume of a sound.
+ * \param sound The sound to change.
+ * \param volume The new volume of the sound. Should be in the range 0 to 1. Use higher values with caution.
+ * \return A handle of the amplified sound.
+ */
+extern AUD_API AUD_Sound* AUD_Sound_volume(AUD_Sound* sound, float volume);
+
+/**
+ * Joins two sound, which means playing them one after the other.
+ * \param first The first sound.
+ * \param second The second sound.
+ * \return A handle of the joined sound.
+ */
+extern AUD_API AUD_Sound* AUD_Sound_join(AUD_Sound* first, AUD_Sound* second);
+
+/**
+ * Mixes two sound, which means superposing the sound samples.
+ * \param first The first sound.
+ * \param second The second sound.
+ * \return A handle of the mixed sound.
+ */
+extern AUD_API AUD_Sound* AUD_Sound_mix(AUD_Sound* first, AUD_Sound* second);
+
+/**
+ * Ping pongs a sound.
+ * \param sound The sound to ping pong.
+ * \return A handle of the ping pong sound.
+ */
+extern AUD_API AUD_Sound* AUD_Sound_pingpong(AUD_Sound* sound);
+
+/**
+ * Unloads a sound of any type.
+ * \param sound The handle of the sound.
+ */
+extern AUD_API void AUD_Sound_free(AUD_Sound* sound);
+
+/**
+ * Copies a sound.
+ * \param sound Sound to copy.
+ * \return Copied sound.
+ */
+extern AUD_API AUD_Sound* AUD_Sound_copy(AUD_Sound* sound);
+
+/**
+ * Creates an empty sound list that can contain several sounds.
+ * \param random A flag that indicates how the list will be played: Randomly or sequentially.
+ *				if 0 the playback will be sequential, if not 0 the playback will be random.
+ * \return A handle of the sound list.
+ */
+extern AUD_API AUD_Sound* AUD_Sound_list(int random);
+
+/**
+* Adds a new sound to a sound list.
+ * \param list The sound list in which the sound will be added.
+ * \param sound The sound that will be added to the list.
+ * \return 0 if the sound couldn't be added (the list parameter isn't a sound list).
+*/
+extern AUD_API int AUD_SoundList_addSound(AUD_Sound* list, AUD_Sound* sound);
+
+/**
+ * Creates a sound that will be restarted when sought backwards. If the original sound is a sound list, the playing sound can change.
+ * \param sound The handle of the sound.
+ * \return A handle of the mutable sound.
+*/
+extern AUD_API AUD_Sound* AUD_Sound_mutable(AUD_Sound* sound);
+
+    /**
+     * Adds Echo effect to the sound.
+     * \param sound The handle of the sound.
+     * \param delay The delay time in seconds.
+     * \param feedback The feedback amount (0.0 to 1.0).
+     * \param mix The wet/dry mix (0.0 to 1.0).
+     * \param resetBuffer Whether to reset the delay buffer on seek.
+     * \return A handle of the time-stretched, pitch scaled sound.
+     */
+extern AUD_API AUD_Sound* AUD_Sound_Echo(AUD_Sound* sound, float delay, float feedback, float mix, bool resetBuffer);
+
+#ifdef WITH_CONVOLUTION
+	extern AUD_API AUD_Sound* AUD_Sound_Convolver(AUD_Sound* sound, AUD_ImpulseResponse* filter, AUD_ThreadPool* threadPool);
+	extern AUD_API AUD_Sound* AUD_Sound_Binaural(AUD_Sound* sound, AUD_HRTF* hrtfs, AUD_Source* source, AUD_ThreadPool* threadPool);
+
+	/**
+	 * Creates an Equalizer for the sound
+	 * \param sound The handle of the sound
+	 * \param definition buffer of size*sizeof(float) with the array of equalization values
+	 * \param maxFreqEq Maximum frequency refered by the array
+	 * \param sizeConversion Size of the transformation. Must be 2^number (for example 1024, 2048,...)
+	 * \return A handle to the Equalizer refered to that sound
+	 */
+	extern AUD_API AUD_Sound* AUD_Sound_equalize(AUD_Sound* sound, float *definition, int size, float maxFreqEq, int sizeConversion);
+#endif
+
+#ifdef WITH_RUBBERBAND
+    /**
+     * Time-stretches and pitch scales a sound.
+     * \param sound The handle of the sound.
+     * \param timeRatio The factor by which to stretch or compress time.
+     * \param pitchScale The factor by which to adjust the pitch.
+     * \param quality The processing quality level of the stretcher.
+     * \param preserveFormant Whether to preserve the vocal formants for the stretcher.
+     * \return A handle of the time-stretched, pitch scaled sound.
+     */
+    extern AUD_API AUD_Sound* AUD_Sound_timeStretchPitchScale(AUD_Sound* sound, double timeRatio, double pitchScale, AUD_StretcherQuality quality, char preserveFormant);
+
+    /**
+     * Time-stretches and pitch scales a sound with animation support
+     * \param sound The handle of the sound.
+     * \param fps The fps
+     * \param timeRatio The initial factor by which to stretch or compress time.
+     * \param pitchScale The initial factor by which to adjust the pitch.
+     * \param quality The processing quality level of the stretcher.
+     * \param preserveFormant Whether to preserve the vocal formants for the stretcher.
+     * \return A handle of the time-stretched, pitch scaled sound.
+     */
+    extern AUD_API AUD_Sound* AUD_Sound_animateableTimeStretchPitchScale(AUD_Sound* sound, float fps, double timeRatio, double pitchScale, AUD_StretcherQuality quality,
+                                                                         char preserveFormant);
+
+    /**
+     * Writes animation data to the AnimatableTimeStretchPitchScale effect
+     * \param sequence The sound scene.
+     * \param type The type of animation data.
+     * \param frame_start Start of the frame range.
+     * \param frame_end End of the frame range.
+     * \param data The data to write.
+     */
+    AUD_API void AUD_Sound_animateableTimeStretchPitchScale_setConstantRangeAnimationData(AUD_Sound* sound, AUD_AnimateablePropertyType type, int frame_start, int frame_end,
+                                                                                          float* data);
+
+    /**
+     * Writes animation data to the AnimatableTimeStretchPitchScale effect
+     * \param entry The sequenced entry.
+     * \param type The type of animation data.
+     * \param frame The frame this data is for.
+     * \param data The data to write.
+     * \param animated Whether the attribute is animated.
+     */
+    extern AUD_API void AUD_Sound_animateableTimeStretchPitchScale_setAnimationData(AUD_Sound* sound, AUD_AnimateablePropertyType type, int frame, float* data, char animated);
+
+    /**
+     * Sets the fps of an animated time-stretch, pitch-scaled sound.
+     * \param sound The sound to set the fps from.
+     * \param value The new fps to set.
+     */
+    extern AUD_API void AUD_Sound_animateableTimeStretchPitchScale_setFPS(AUD_Sound* sound, AUD_AnimateablePropertyType type, int frame, float* data, char animated);
+
+    /**
+     * Retrieves the fps of an animated time-stretch, pitch-scaled sound.
+     * \param sequence The sound to get the fps from.
+     * \return The fps of the sound.
+     */
+    extern AUD_API float AUD_Sound_animateableTimeStretchPitchScale_getFPS(AUD_Sound* sequence);
+
+    /**
+     * Checks if sound is an instance of AnimateableTimeStretchPitchScale effect.
+     */
+    extern AUD_API bool AUD_Sound_isAnimateableTimeStretchPitchScale(AUD_Sound* sound);
+#endif
+
+#ifdef __cplusplus
+}
+#endif

blender-5.2.0/extern/audaspace/bindings/C/AUD_Source.cpp

@@ -0,0 +1,84 @@
+/*******************************************************************************
+* Copyright 2009-2015 Juan Francisco Crespo Galán
+*
+* 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 "Exception.h"
+
+#include <cassert>
+
+using namespace aud;
+
+#define AUD_CAPI_IMPLEMENTATION
+#include "AUD_Source.h"
+
+extern AUD_API AUD_Source* AUD_Source_create(float azimuth, float elevation, float distance)
+{
+	try
+	{
+		return new AUD_Source(new Source(azimuth, elevation, distance));
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+}
+
+extern AUD_API void AUD_Source_free(AUD_Source* source)
+{
+	assert(source);
+	delete source;
+}
+
+extern AUD_API float AUD_Source_getAzimuth(AUD_Source* source)
+{
+	assert(source);
+
+	return (*source)->getAzimuth();
+}
+
+extern AUD_API float AUD_Source_getElevation(AUD_Source* source)
+{
+	assert(source);
+
+	return (*source)->getElevation();
+}
+
+extern AUD_API float AUD_Source_getDistance(AUD_Source* source)
+{
+	assert(source);
+
+	return (*source)->getDistance();
+}
+
+extern AUD_API void AUD_Source_setAzimuth(AUD_Source* source, float azimuth)
+{
+	assert(source);
+
+	(*source)->setAzimuth(azimuth);
+}
+
+extern AUD_API void AUD_Source_setElevation(AUD_Source* source, float elevation)
+{
+	assert(source);
+
+	(*source)->setElevation(elevation);
+}
+
+extern AUD_API void AUD_Source_setDistance(AUD_Source* source, float distance)
+{
+	assert(source);
+
+	(*source)->setDistance(distance);
+}

blender-5.2.0/extern/audaspace/bindings/C/AUD_Source.h

@@ -0,0 +1,84 @@
+/*******************************************************************************
+* Copyright 2009-2015 Juan Francisco Crespo Galán
+*
+* 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.
+******************************************************************************/
+
+#pragma once
+
+#include "AUD_Types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+* Creates a new Source object.
+* \param azimuth The azimuth angle.
+* \param elevation The elevation angle.
+* \param elevation The distance value. [0,1]
+* \return The new Source object.
+*/
+extern AUD_API AUD_Source* AUD_Source_create(float azimuth, float elevation, float distance);
+
+/**
+* Deletes a Source object.
+* \param source The Source object to be deleted.
+*/
+extern AUD_API void AUD_Source_free(AUD_Source* source);
+
+/**
+* Retrieves the azimuth angle of a Source object.
+* \param source The Source object.
+* \return The azimuth angle.
+*/
+extern AUD_API float AUD_Source_getAzimuth(AUD_Source* source);
+
+/**
+* Retrieves the elevation angle oa a Source object.
+* \param source The Source object.
+* \return The elevation angle.
+*/
+extern AUD_API float AUD_Source_getElevation(AUD_Source* source);
+
+/**
+* Retrieves the distance of a Source object. [0,1]
+* \param source The Source object.
+* \return The distance.
+*/
+extern AUD_API float AUD_Source_getDistance(AUD_Source* distance);
+
+/**
+* Changes the azimuth angle of a Source object.
+* \param source The Source object.
+* \param azimuth The azimuth angle.
+*/
+extern AUD_API void AUD_Source_setAzimuth(AUD_Source* source, float azimuth);
+
+/**
+* Changes the elevation angle of a Source object.
+* \param source The Source object.
+* \param elevation The elevation angle.
+*/
+extern AUD_API void AUD_Source_setElevation(AUD_Source* source, float elevation);
+
+/**
+* Changes the distance of a Source object. [0,1]
+* \param source The Source object.
+* \param distance The distance.
+*/
+extern AUD_API void AUD_Source_setDistance(AUD_Source* source, float distance);
+
+#ifdef __cplusplus
+}
+#endif

blender-5.2.0/extern/audaspace/bindings/C/AUD_Special.cpp

@@ -0,0 +1,430 @@
+/*******************************************************************************
+ * 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 "Exception.h"
+#include "IReader.h"
+#include "file/File.h"
+#include "respec/ChannelMapper.h"
+#include "fx/Lowpass.h"
+#include "fx/Highpass.h"
+#include "fx/Envelope.h"
+#include "respec/LinearResample.h"
+#include "fx/Threshold.h"
+#include "fx/Accumulator.h"
+#include "fx/Sum.h"
+#include "generator/Silence.h"
+#include "fx/Limiter.h"
+#include "devices/DeviceManager.h"
+#include "sequence/Sequence.h"
+#include "file/FileWriter.h"
+#include "devices/ReadDevice.h"
+#include "plugin/PluginManager.h"
+#include "devices/DeviceManager.h"
+#include "devices/IDeviceFactory.h"
+#include "devices/NULLDevice.h"
+
+#include <cassert>
+#include <cstring>
+#include <cmath>
+#include <sstream>
+
+using namespace aud;
+
+#define AUD_CAPI_IMPLEMENTATION
+#include "AUD_Special.h"
+
+static inline AUD_Specs convSpecToC(aud::Specs specs)
+{
+	AUD_Specs s;
+	s.channels = static_cast<AUD_Channels>(specs.channels);
+	s.rate = static_cast<AUD_SampleRate>(specs.rate);
+	return s;
+}
+
+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 convDSpecToC(aud::DeviceSpecs specs)
+{
+	AUD_DeviceSpecs s;
+	s.specs = convSpecToC(specs.specs);
+	s.format = static_cast<AUD_SampleFormat>(specs.format);
+	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_SoundInfo AUD_getInfo(AUD_Sound* sound)
+{
+	assert(sound);
+
+	AUD_SoundInfo info;
+	info.specs.channels = AUD_CHANNELS_INVALID;
+	info.specs.rate = AUD_RATE_INVALID;
+	info.length = 0.0f;
+
+	try
+	{
+		std::shared_ptr<IReader> reader = (*sound)->createReader();
+
+		if(reader.get())
+		{
+			info.specs = convSpecToC(reader->getSpecs());
+			info.length = reader->getLength() / (float) info.specs.rate;
+		}
+	}
+	catch(Exception&)
+	{
+	}
+
+	return info;
+}
+
+AUD_API float* AUD_readSoundBuffer(const char* filename, float low, float high,
+						   float attack, float release, float threshold,
+						   int accumulate, int additive, int square,
+						   float sthreshold, double samplerate, int* length, int stream)
+{
+	Buffer buffer;
+	DeviceSpecs specs;
+	specs.channels = CHANNELS_MONO;
+	specs.rate = (SampleRate)samplerate;
+	std::shared_ptr<ISound> sound;
+
+	std::shared_ptr<ISound> file = std::shared_ptr<ISound>(new File(filename, stream));
+
+	int position = 0;
+
+	try
+	{
+		std::shared_ptr<IReader> reader = file->createReader();
+
+		SampleRate rate = reader->getSpecs().rate;
+
+		sound = std::shared_ptr<ISound>(new ChannelMapper(file, specs));
+
+		if(high < rate)
+			sound = std::shared_ptr<ISound>(new Lowpass(sound, high));
+		if(low > 0)
+			sound = std::shared_ptr<ISound>(new Highpass(sound, low));
+
+		sound = std::shared_ptr<ISound>(new Envelope(sound, attack, release, threshold, 0.1f));
+		sound = std::shared_ptr<ISound>(new LinearResample(sound, specs));
+
+		if(square)
+			sound = std::shared_ptr<ISound>(new Threshold(sound, sthreshold));
+
+		if(accumulate)
+			sound = std::shared_ptr<ISound>(new Accumulator(sound, additive));
+		else if(additive)
+			sound = std::shared_ptr<ISound>(new Sum(sound));
+
+		reader = sound->createReader();
+
+		if(!reader.get())
+			return nullptr;
+
+		int len;
+		bool eos;
+		do
+		{
+			len = samplerate;
+			buffer.resize((position + len) * sizeof(float), true);
+			reader->read(len, eos, buffer.getBuffer() + position);
+			position += len;
+		} while(!eos);
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+
+	float * result = (float *)malloc(position * sizeof(float));
+	std::memcpy(result, buffer.getBuffer(), position * sizeof(float));
+	*length = position;
+	return result;
+}
+
+static void pauseSound(AUD_Handle* handle)
+{
+	assert(handle);
+	(*handle)->pause();
+}
+
+AUD_API AUD_Handle* AUD_pauseAfter(AUD_Handle* handle, double seconds)
+{
+	auto device = DeviceManager::getDevice();
+
+	std::shared_ptr<ISound> silence = std::shared_ptr<ISound>(new Silence(device->getSpecs().rate));
+	std::shared_ptr<ISound> limiter = std::shared_ptr<ISound>(new Limiter(silence, 0, seconds));
+
+	std::lock_guard<ILockable> lock(*device);
+
+	try
+	{
+		AUD_Handle handle2 = device->play(limiter);
+		if(handle2.get())
+		{
+			handle2->setStopCallback((stopCallback)pauseSound, handle);
+			return new AUD_Handle(handle2);
+		}
+	}
+	catch(Exception&)
+	{
+	}
+
+	return nullptr;
+}
+
+AUD_API int AUD_readSound(AUD_Sound* sound, float* buffer, int length, int samples_per_second, bool* interrupt)
+{
+	DeviceSpecs specs;
+	float* buf;
+	Buffer aBuffer;
+
+	specs.rate = RATE_INVALID;
+	specs.channels = CHANNELS_MONO;
+	specs.format = FORMAT_INVALID;
+
+	std::shared_ptr<IReader> reader = ChannelMapper(*sound, specs).createReader();
+
+	specs.specs = reader->getSpecs();
+	int len;
+	float samplejump = specs.rate / samples_per_second;
+	float min, max, power, overallmax;
+	bool eos;
+
+	overallmax = 0;
+
+	for(int i = 0; i < length; i++)
+	{
+		len = floor(samplejump * (i+1)) - floor(samplejump * i);
+
+		if(*interrupt)
+			return 0;
+
+		aBuffer.assureSize(len * AUD_SAMPLE_SIZE(specs));
+		buf = aBuffer.getBuffer();
+
+		reader->read(len, eos, buf);
+
+		max = min = *buf;
+		power = *buf * *buf;
+		for(int j = 1; j < len; j++)
+		{
+			if(buf[j] < min)
+				min = buf[j];
+			if(buf[j] > max)
+				max = buf[j];
+			power += buf[j] * buf[j];
+		}
+
+		buffer[i * 3] = min;
+		buffer[i * 3 + 1] = max;
+		buffer[i * 3 + 2] = std::sqrt(power / len);
+
+		if(overallmax < max)
+			overallmax = max;
+		if(overallmax < -min)
+			overallmax = -min;
+
+		if(eos)
+		{
+			length = i;
+			break;
+		}
+	}
+
+	if(overallmax > 1.0f)
+	{
+		for(int i = 0; i < length * 3; i++)
+		{
+			buffer[i] /= overallmax;
+		}
+	}
+
+	return length;
+}
+
+AUD_API int AUD_mixdown(AUD_Sound* sound, unsigned int start, unsigned int length, unsigned int buffersize, const char* filename, AUD_DeviceSpecs specs, AUD_Container format, AUD_Codec codec, unsigned int bitrate, AUD_ResampleQuality quality, bool(*callback)(float, void*), void* data, char* error, size_t errorsize)
+{
+	try
+	{
+		Sequence* f = dynamic_cast<Sequence *>(sound->get());
+
+		f->setSpecs(convCToSpec(specs.specs));
+		std::shared_ptr<IReader> reader = f->createQualityReader(static_cast<ResampleQuality>(quality));
+		reader->seek(start);
+		std::shared_ptr<IWriter> writer = FileWriter::createWriter(filename, convCToDSpec(specs), static_cast<Container>(format), static_cast<Codec>(codec), bitrate);
+		FileWriter::writeReader(reader, writer, length, buffersize, callback, data);
+
+		return true;
+	}
+	catch(Exception& e)
+	{
+		if(error && errorsize)
+		{
+			std::strncpy(error, e.getMessage().c_str(), errorsize);
+			error[errorsize - 1] = '\0';
+		}
+		return false;
+	}
+}
+
+AUD_API int AUD_mixdown_per_channel(AUD_Sound* sound, unsigned int start, unsigned int length, unsigned int buffersize, const char* filename, AUD_DeviceSpecs specs, AUD_Container format, AUD_Codec codec, unsigned int bitrate, AUD_ResampleQuality quality, bool(*callback)(float, void*), void* data, char* error, size_t errorsize)
+{
+	try
+	{
+		Sequence* f = dynamic_cast<Sequence *>(sound->get());
+
+		f->setSpecs(convCToSpec(specs.specs));
+
+		std::vector<std::shared_ptr<IWriter> > writers;
+
+		int channels = specs.channels;
+		specs.channels = AUD_CHANNELS_MONO;
+
+		for(int i = 0; i < channels; i++)
+		{
+			std::stringstream stream;
+			std::string fn = filename;
+			size_t index = fn.find_last_of('.');
+			size_t index_slash = fn.find_last_of('/');
+			size_t index_backslash = fn.find_last_of('\\');
+
+			if((index == std::string::npos) ||
+				((index < index_slash) && (index_slash != std::string::npos)) ||
+				((index < index_backslash) && (index_backslash != std::string::npos)))
+			{
+				stream << filename << "_" << (i + 1);
+			}
+			else
+			{
+				stream << fn.substr(0, index) << "_" << (i + 1) << fn.substr(index);
+			}
+			writers.push_back(FileWriter::createWriter(stream.str(), convCToDSpec(specs), static_cast<Container>(format), static_cast<Codec>(codec), bitrate));
+		}
+
+		std::shared_ptr<IReader> reader = f->createQualityReader(static_cast<ResampleQuality>(quality));
+		reader->seek(start);
+		FileWriter::writeReader(reader, writers, length, buffersize, callback, data);
+
+		return true;
+	}
+	catch(Exception& e)
+	{
+		if(error && errorsize)
+		{
+			std::strncpy(error, e.getMessage().c_str(), errorsize);
+			error[errorsize - 1] = '\0';
+		}
+		return false;
+	}
+}
+
+AUD_API AUD_Device* AUD_openMixdownDevice(AUD_DeviceSpecs specs, AUD_Sound* sequencer, float volume, AUD_ResampleQuality quality, double start)
+{
+	try
+	{
+		ReadDevice* device = new ReadDevice(convCToDSpec(specs));
+		device->setQuality(static_cast<ResampleQuality>(quality));
+		device->setVolume(volume);
+
+		Sequence* f = dynamic_cast<Sequence*>(sequencer->get());
+
+		f->setSpecs(convCToSpec(specs.specs));
+
+		AUD_Handle handle = device->play(f->createQualityReader(static_cast<ResampleQuality>(quality)));
+		if(handle.get())
+		{
+			handle->seek(start);
+		}
+
+		return new AUD_Device(device);
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+}
+
+AUD_API void AUD_initOnce()
+{
+	PluginManager::loadPlugins();
+	NULLDevice::registerPlugin();
+}
+
+AUD_API void AUD_exitOnce()
+{
+}
+
+AUD_API AUD_Device* AUD_init(const char* device, AUD_DeviceSpecs specs, int buffersize, const char* name)
+{
+	try
+	{
+		std::shared_ptr<IDeviceFactory> factory = device ? DeviceManager::getDeviceFactory(device) : DeviceManager::getDefaultDeviceFactory();
+
+		if(factory)
+		{
+			factory->setName(name);
+			factory->setBufferSize(buffersize);
+			factory->setSpecs(convCToDSpec(specs));
+			auto device = factory->openDevice();
+			DeviceManager::setDevice(device);
+
+			return new AUD_Device(device);
+		}
+	}
+	catch(Exception&)
+	{
+	}
+	return nullptr;
+}
+
+AUD_API void AUD_exit(AUD_Device* device)
+{
+	delete device;
+	DeviceManager::releaseDevice();
+}
+
+
+AUD_API char** AUD_getDeviceNames()
+{
+	std::vector<std::string> v_names = DeviceManager::getAvailableDeviceNames();
+	char** names = (char**) malloc(sizeof(char*) * (v_names.size() + 1));
+
+	for(int i = 0; i < v_names.size(); i++)
+	{
+		std::string name = v_names[i];
+		names[i] = (char*) malloc(sizeof(char) * (name.length() + 1));
+		strcpy(names[i], name.c_str());
+	}
+
+	names[v_names.size()] = nullptr;
+
+	return names;
+}

blender-5.2.0/extern/audaspace/bindings/C/AUD_Special.h

@@ -0,0 +1,155 @@
+/*******************************************************************************
+ * 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.
+ ******************************************************************************/
+
+#pragma once
+
+#include "AUD_Types.h"
+
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Returns information about a sound.
+ * \param sound The sound to get the info about.
+ * \return The AUD_SoundInfo structure with filled in data.
+ */
+extern AUD_API AUD_SoundInfo AUD_getInfo(AUD_Sound* sound);
+
+/**
+ * Reads a sound file into a newly created float buffer.
+ * The sound is therefore bandpassed, rectified and resampled.
+ */
+extern AUD_API float* AUD_readSoundBuffer(const char* filename, float low, float high,
+								  float attack, float release, float threshold,
+								  int accumulate, int additive, int square,
+								  float sthreshold, double samplerate,
+								  int* length, int stream);
+
+/**
+ * Pauses a playing sound after a specific amount of time.
+ * \param handle The handle to the sound.
+ * \param seconds The time in seconds.
+ * \return The silence handle.
+ */
+extern AUD_API AUD_Handle* AUD_pauseAfter(AUD_Handle* handle, double seconds);
+
+/**
+ * Reads a sound into a buffer for drawing at a specific sampling rate.
+ * \param sound The sound to read.
+ * \param buffer The buffer to write to. Must have a size of 3*4*length.
+ * \param length How many samples to read from the sound.
+ * \param samples_per_second How many samples to read per second of the sound.
+ * \param interrupt Must point to a bool that equals false. If it is set to true, the method will be interrupted and return 0.
+ * \return How many samples really have been read. Always <= length.
+ */
+extern AUD_API int AUD_readSound(AUD_Sound* sound, float* buffer, int length, int samples_per_second, bool* interrupt);
+
+/**
+ * Mixes a sound down into a file.
+ * \param sound The sound scene to mix down.
+ * \param start The start frame.
+ * \param length The count of frames to write.
+ * \param buffersize How many samples should be written at once.
+ * \param filename The file to write to.
+ * \param specs The file's audio specification.
+ * \param format The file's container format.
+ * \param codec The codec used for encoding the audio data.
+ * \param bitrate The bitrate for encoding.
+ * \param quality The resampling quality.
+ * \param callback A callback function that is called periodically during mixdown, reporting progress if length > 0. Mixdown is canceled if the callback returns false. Can be NULL.
+ * \param data Pass through parameter that is passed to the callback.
+ * \param error String buffer to copy the error message to in case of failure.
+ * \param errorsize The size of the error buffer.
+ * \return Whether or not the operation succeeded.
+ */
+extern AUD_API int AUD_mixdown(AUD_Sound* sound, unsigned int start, unsigned int length,
+							   unsigned int buffersize, const char* filename,
+							   AUD_DeviceSpecs specs, AUD_Container format,
+							   AUD_Codec codec, unsigned int bitrate, AUD_ResampleQuality quality,
+							   bool(*callback)(float, void*), void* data, char* error, size_t errorsize);
+
+/**
+ * Mixes a sound down into multiple files.
+ * \param sound The sound scene to mix down.
+ * \param start The start frame.
+ * \param length The count of frames to write.
+ * \param buffersize How many samples should be written at once.
+ * \param filename The file to write to, the channel number and an underscore are added at the beginning.
+ * \param specs The file's audio specification.
+ * \param format The file's container format.
+ * \param codec The codec used for encoding the audio data.
+ * \param bitrate The bitrate for encoding.
+ * \param quality The resampling quality.
+ * \param callback A callback function that is called periodically during mixdown, reporting progress if length > 0. Mixdown is canceled if the callback returns false. Can be NULL.
+ * \param data Pass through parameter that is passed to the callback.
+ * \param error String buffer to copy the error message to in case of failure.
+ * \param errorsize The size of the error buffer.
+ * \return Whether or not the operation succeeded.
+ */
+extern AUD_API int AUD_mixdown_per_channel(AUD_Sound* sound, unsigned int start, unsigned int length,
+										   unsigned int buffersize, const char* filename,
+										   AUD_DeviceSpecs specs, AUD_Container format,
+										   AUD_Codec codec, unsigned int bitrate, AUD_ResampleQuality quality,
+										   bool(*callback)(float, void*), void* data, char* error, size_t errorsize);
+
+/**
+ * Opens a read device and prepares it for mixdown of the sound scene.
+ * \param specs Output audio specifications.
+ * \param sequencer The sound scene to mix down.
+ * \param volume The overall mixdown volume.
+ * \param quality The resampling quality.
+ * \param start The start time of the mixdown in the sound scene.
+ * \return The read device for the mixdown.
+ */
+extern AUD_API AUD_Device* AUD_openMixdownDevice(AUD_DeviceSpecs specs, AUD_Sound* sequencer,
+												 float volume, AUD_ResampleQuality quality, double start);
+
+/**
+ * Initializes audio routines (FFMPEG/JACK if it is enabled).
+ */
+extern AUD_API void AUD_initOnce();
+
+/**
+ * Unitinitializes an audio routines.
+ */
+extern AUD_API void AUD_exitOnce();
+
+/**
+ * Initializes an audio device.
+ * \param device The device type that should be used.
+ * \param specs The audio specification to be used.
+ * \param buffersize The buffersize for the device.
+ * \return Whether the device has been initialized.
+ */
+extern AUD_API AUD_Device* AUD_init(const char* device, AUD_DeviceSpecs specs, int buffersize, const char* name);
+
+/**
+ * Unitinitializes an audio device.
+ * \param device The device to free.
+ */
+extern AUD_API void AUD_exit(AUD_Device* device);
+
+/**
+ * Retrieves available devices. Note that all memory returned has to be freed!
+ */
+extern AUD_API char** AUD_getDeviceNames();
+
+#ifdef __cplusplus
+}
+#endif

blender-5.2.0/extern/audaspace/bindings/C/AUD_ThreadPool.cpp

@@ -0,0 +1,42 @@
+/*******************************************************************************
+* Copyright 2009-2015 Juan Francisco Crespo Galán
+*
+* 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 "Exception.h"
+
+#include <cassert>
+
+using namespace aud;
+
+#define AUD_CAPI_IMPLEMENTATION
+#include "AUD_ThreadPool.h"
+
+AUD_API AUD_ThreadPool* AUD_ThreadPool_create(int nThreads)
+{
+	try
+	{
+		return new AUD_ThreadPool(new ThreadPool(nThreads));
+	}
+	catch(Exception&)
+	{
+		return nullptr;
+	}
+}
+
+AUD_API void AUD_ThreadPool_free(AUD_ThreadPool* pool)
+{
+	assert(pool);
+	delete pool;
+}

blender-5.2.0/extern/audaspace/bindings/C/AUD_ThreadPool.h

@@ -0,0 +1,40 @@
+/*******************************************************************************
+* Copyright 2009-2015 Juan Francisco Crespo Galán
+*
+* 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.
+******************************************************************************/
+
+#pragma once
+
+#include "AUD_Types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+* Creates a new ThreadPool object.
+* \param nThreads The number of threads of the pool.
+* \return The new ThreadPool object.
+*/
+extern AUD_API AUD_ThreadPool* AUD_ThreadPool_create(int nThreads);
+
+/**
+* Deletes a ThreadPool object.
+* \param threadPool The ThreadPool object to be deleted.
+*/
+extern AUD_API void AUD_ThreadPool_free(AUD_ThreadPool* threadPool);
+
+#ifdef __cplusplus
+}
+#endif

blender-5.2.0/extern/audaspace/bindings/C/AUD_Types.h

@@ -0,0 +1,224 @@
+/*******************************************************************************
+ * 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.
+ ******************************************************************************/
+
+#pragma once
+
+#include "Audaspace.h"
+
+#ifdef __cplusplus
+using namespace aud;
+#endif
+
+#ifdef AUD_CAPI_IMPLEMENTATION
+#include "ISound.h"
+#include "devices/IHandle.h"
+#include "devices/IDevice.h"
+#include "sequence/SequenceEntry.h"
+#include "fx/PlaybackManager.h"
+#include "fx/DynamicMusic.h"
+#include "fx/Source.h"
+#include "util/ThreadPool.h"
+#ifdef WITH_CONVOLUTION
+#include "fx/ImpulseResponse.h"
+#include "fx/HRTF.h"
+#endif
+
+typedef std::shared_ptr<aud::ISound> AUD_Sound;
+typedef std::shared_ptr<aud::IHandle> AUD_Handle;
+typedef std::shared_ptr<aud::IDevice> AUD_Device;
+typedef std::shared_ptr<aud::SequenceEntry> AUD_SequenceEntry;
+typedef std::shared_ptr<aud::PlaybackManager> AUD_PlaybackManager;
+typedef std::shared_ptr<aud::DynamicMusic> AUD_DynamicMusic;
+typedef std::shared_ptr<aud::ThreadPool> AUD_ThreadPool;
+typedef std::shared_ptr<aud::Source> AUD_Source;
+#ifdef WITH_CONVOLUTION
+typedef std::shared_ptr<aud::ImpulseResponse> AUD_ImpulseResponse;
+typedef std::shared_ptr<aud::HRTF> AUD_HRTF;
+#endif
+#else
+typedef void AUD_Sound;
+typedef void AUD_Handle;
+typedef void AUD_Device;
+typedef void AUD_SequenceEntry;
+typedef void AUD_PlaybackManager;
+typedef void AUD_DynamicMusic;
+typedef void AUD_ThreadPool;
+typedef void AUD_Source;
+#ifdef WITH_CONVOLUTION
+typedef void AUD_ImpulseResponse;
+typedef void AUD_HRTF;
+#endif
+#endif
+
+/// Container formats for writers.
+typedef enum
+{
+	AUD_CONTAINER_INVALID = 0,
+	AUD_CONTAINER_AC3,
+	AUD_CONTAINER_FLAC,
+	AUD_CONTAINER_MATROSKA,
+	AUD_CONTAINER_MP2,
+	AUD_CONTAINER_MP3,
+	AUD_CONTAINER_OGG,
+	AUD_CONTAINER_WAV,
+	AUD_CONTAINER_AAC
+} AUD_Container;
+
+/// Audio codecs for writers.
+typedef enum
+{
+	AUD_CODEC_INVALID = 0,
+	AUD_CODEC_AAC,
+	AUD_CODEC_AC3,
+	AUD_CODEC_FLAC,
+	AUD_CODEC_MP2,
+	AUD_CODEC_MP3,
+	AUD_CODEC_PCM,
+	AUD_CODEC_VORBIS,
+	AUD_CODEC_OPUS
+} AUD_Codec;
+
+/**
+ * The format of a sample.
+ * The last 4 bit save the byte count of the format.
+ */
+typedef enum
+{
+	AUD_FORMAT_INVALID = 0x00,		/// Invalid sample format.
+	AUD_FORMAT_U8      = 0x01,		/// 1 byte unsigned byte.
+	AUD_FORMAT_S16     = 0x12,		/// 2 byte signed integer.
+	AUD_FORMAT_S24     = 0x13,		/// 3 byte signed integer.
+	AUD_FORMAT_S32     = 0x14,		/// 4 byte signed integer.
+	AUD_FORMAT_FLOAT32 = 0x24,		/// 4 byte float.
+	AUD_FORMAT_FLOAT64 = 0x28		/// 8 byte float.
+} AUD_SampleFormat;
+
+/// The channel count.
+typedef enum
+{
+	AUD_CHANNELS_INVALID    = 0,	/// Invalid channel count.
+	AUD_CHANNELS_MONO       = 1,	/// Mono.
+	AUD_CHANNELS_STEREO     = 2,	/// Stereo.
+	AUD_CHANNELS_STEREO_LFE = 3,	/// Stereo with LFE channel.
+	AUD_CHANNELS_SURROUND4  = 4,	/// 4 channel surround sound.
+	AUD_CHANNELS_SURROUND5  = 5,	/// 5 channel surround sound.
+	AUD_CHANNELS_SURROUND51 = 6,	/// 5.1 surround sound.
+	AUD_CHANNELS_SURROUND61 = 7,	/// 6.1 surround sound.
+	AUD_CHANNELS_SURROUND71 = 8	/// 7.1 surround sound.
+} AUD_Channels;
+
+/// Resampling algorithm and quality.
+typedef enum
+{
+	AUD_RESAMPLE_QUALITY_FASTEST = 0, /// Linear resample, very fast but lowest quality.
+	AUD_RESAMPLE_QUALITY_LOW     = 1, /// JOS resample at low quality preset.
+	AUD_RESAMPLE_QUALITY_MEDIUM  = 2, /// JOS resample at medium quality preset.
+	AUD_RESAMPLE_QUALITY_HIGH    = 3  /// JOS resample at high quality preset.
+} AUD_ResampleQuality;
+
+/**
+ * The sample rate tells how many samples are played back within one second.
+ * Some exotic formats may use other sample rates than provided here.
+ */
+typedef enum
+{
+	AUD_RATE_INVALID = 0,			/// Invalid sample rate.
+	AUD_RATE_8000    = 8000,		/// 8000 Hz.
+	AUD_RATE_16000   = 16000,		/// 16000 Hz.
+	AUD_RATE_11025   = 11025,		/// 11025 Hz.
+	AUD_RATE_22050   = 22050,		/// 22050 Hz.
+	AUD_RATE_32000   = 32000,		/// 32000 Hz.
+	AUD_RATE_44100   = 44100,		/// 44100 Hz.
+	AUD_RATE_48000   = 48000,		/// 48000 Hz.
+	AUD_RATE_88200   = 88200,		/// 88200 Hz.
+	AUD_RATE_96000   = 96000,		/// 96000 Hz.
+	AUD_RATE_192000  = 192000		/// 192000 Hz.
+} AUD_DefaultSampleRate;
+
+/// Sample rate type.
+typedef double AUD_SampleRate;
+
+/// Specification of a sound source.
+typedef struct
+{
+	/// Sample rate in Hz.
+	AUD_SampleRate rate;
+
+	/// Channel count.
+	AUD_Channels channels;
+} AUD_Specs;
+
+/// Specification of a sound device.
+typedef struct
+{
+	/// Sample format.
+	AUD_SampleFormat format;
+
+	union
+	{
+		struct
+		{
+			/// Sample rate in Hz.
+			AUD_SampleRate rate;
+
+			/// Channel count.
+			AUD_Channels channels;
+		};
+		AUD_Specs specs;
+	};
+} AUD_DeviceSpecs;
+
+/// Sound information structure.
+typedef struct
+{
+	AUD_Specs specs;
+	float length;
+} AUD_SoundInfo;
+
+/// Specification of a sound source.
+typedef struct
+{
+	/// Start time in seconds.
+	double start;
+
+	/// Duration in seconds. May be estimated or 0 if unknown.
+	double duration;
+
+	/// Audio data parameters.
+	AUD_DeviceSpecs specs;
+} AUD_StreamInfo;
+
+/**
+ * The Rubber Band stretcher quality.
+ */
+typedef enum
+{
+	AUD_STRETCHER_QUALITY_HIGH = 0,      /// Prioritize high-quality pitch processing
+	AUD_STRETCHER_QUALITY_FAST = 1,      /// Prioritize speed over audio quality
+	AUD_STRETCHER_QUALITY_CONSISTENT = 2 /// Prioritize consistency for dynamic pitch changes
+} AUD_StretcherQuality;
+
+/// Possible animatable properties for Sequence Factories and Entries.
+typedef enum
+{
+	AUD_AP_VOLUME,
+	AUD_AP_PANNING,
+	AUD_AP_PITCH,
+	AUD_AP_LOCATION,
+	AUD_AP_ORIENTATION,
+	AUD_AP_TIME_STRETCH,
+	AUD_AP_PITCH_SCALE
+} AUD_AnimateablePropertyType;

blender-5.2.0/extern/audaspace/bindings/doc/conf.py.in

@@ -0,0 +1,261 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# audaspace documentation build configuration file, created by
+# sphinx-quickstart on Tue Sep  9 01:48:48 2014.
+#
+# This file is execfile()d with the current directory set to its
+# containing dir.
+#
+# Note that not all possible configuration values are present in this
+# autogenerated file.
+#
+# All configuration values have a default; values that are commented out
+# serve to show the default.
+
+import sys
+import os
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#sys.path.insert(0, os.path.abspath('.'))
+
+# -- General configuration ------------------------------------------------
+
+# If your documentation needs a minimal Sphinx version, state it here.
+#needs_sphinx = '1.0'
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+    'sphinx.ext.autodoc',
+]
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = []
+
+# The suffix of source filenames.
+source_suffix = '.rst'
+
+# The encoding of source files.
+#source_encoding = 'utf-8-sig'
+
+# The master toctree document.
+master_doc = 'index'
+
+# General information about the project.
+project = 'audaspace'
+copyright = '2009-2015, Jörg Müller'
+
+# The version info for the project you're documenting, acts as replacement for
+# |version| and |release|, also used in various other places throughout the
+# built documents.
+#
+# The short X.Y version.
+version = '@AUDASPACE_VERSION@'
+# The full version, including alpha/beta/rc tags.
+release = '@AUDASPACE_LONG_VERSION@'
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+#language = None
+
+# There are two options for replacing |today|: either, you set today to some
+# non-false value, then it is used:
+#today = ''
+# Else, today_fmt is used as the format for a strftime call.
+#today_fmt = '%B %d, %Y'
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+exclude_patterns = []
+
+# The reST default role (used for this markup: `text`) to use for all
+# documents.
+#default_role = None
+
+# If true, '()' will be appended to :func: etc. cross-reference text.
+#add_function_parentheses = True
+
+# If true, the current module name will be prepended to all description
+# unit titles (such as .. function::).
+#add_module_names = True
+
+# If true, sectionauthor and moduleauthor directives will be shown in the
+# output. They are ignored by default.
+#show_authors = False
+
+# The name of the Pygments (syntax highlighting) style to use.
+pygments_style = 'sphinx'
+
+# A list of ignored prefixes for module index sorting.
+#modindex_common_prefix = []
+
+# If true, keep warnings as "system message" paragraphs in the built documents.
+#keep_warnings = False
+
+
+# -- Options for HTML output ----------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+html_theme = 'alabaster'
+
+# Theme options are theme-specific and customize the look and feel of a theme
+# further.  For a list of options available for each theme, see the
+# documentation.
+#html_theme_options = {}
+
+# Add any paths that contain custom themes here, relative to this directory.
+#html_theme_path = []
+
+# The name for this set of Sphinx documents.  If None, it defaults to
+# "<project> v<release> documentation".
+#html_title = None
+
+# A shorter title for the navigation bar.  Default is the same as html_title.
+#html_short_title = None
+
+# The name of an image file (relative to this directory) to place at the top
+# of the sidebar.
+#html_logo = None
+
+# The name of an image file (within the static path) to use as favicon of the
+# docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
+# pixels large.
+#html_favicon = None
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = []
+
+# Add any extra paths that contain custom files (such as robots.txt or
+# .htaccess) here, relative to this directory. These files are copied
+# directly to the root of the documentation.
+#html_extra_path = []
+
+# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
+# using the given strftime format.
+#html_last_updated_fmt = '%b %d, %Y'
+
+# If true, SmartyPants will be used to convert quotes and dashes to
+# typographically correct entities.
+#html_use_smartypants = True
+
+# Custom sidebar templates, maps document names to template names.
+#html_sidebars = {}
+
+# Additional templates that should be rendered to pages, maps page names to
+# template names.
+#html_additional_pages = {}
+
+# If false, no module index is generated.
+#html_domain_indices = True
+
+# If false, no index is generated.
+#html_use_index = True
+
+# If true, the index is split into individual pages for each letter.
+#html_split_index = False
+
+# If true, links to the reST sources are added to the pages.
+#html_show_sourcelink = True
+
+# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
+#html_show_sphinx = True
+
+# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
+#html_show_copyright = True
+
+# If true, an OpenSearch description file will be output, and all pages will
+# contain a <link> tag referring to it.  The value of this option must be the
+# base URL from which the finished HTML is served.
+#html_use_opensearch = ''
+
+# This is the file name suffix for HTML files (e.g. ".xhtml").
+#html_file_suffix = None
+
+# Output file base name for HTML help builder.
+htmlhelp_basename = 'audaspacedoc'
+
+
+# -- Options for LaTeX output ---------------------------------------------
+
+latex_elements = {
+# The paper size ('letterpaper' or 'a4paper').
+#'papersize': 'letterpaper',
+
+# The font size ('10pt', '11pt' or '12pt').
+#'pointsize': '10pt',
+
+# Additional stuff for the LaTeX preamble.
+#'preamble': '',
+}
+
+# Grouping the document tree into LaTeX files. List of tuples
+# (source start file, target name, title,
+#  author, documentclass [howto, manual, or own class]).
+latex_documents = [
+  ('index', 'audaspace.tex', 'audaspace Documentation',
+   'Jörg Müller', 'manual'),
+]
+
+# The name of an image file (relative to this directory) to place at the top of
+# the title page.
+#latex_logo = None
+
+# For "manual" documents, if this is true, then toplevel headings are parts,
+# not chapters.
+#latex_use_parts = False
+
+# If true, show page references after internal links.
+#latex_show_pagerefs = False
+
+# If true, show URL addresses after external links.
+#latex_show_urls = False
+
+# Documents to append as an appendix to all manuals.
+#latex_appendices = []
+
+# If false, no module index is generated.
+#latex_domain_indices = True
+
+
+# -- Options for manual page output ---------------------------------------
+
+# One entry per manual page. List of tuples
+# (source start file, name, description, authors, manual section).
+man_pages = [
+    ('index', 'audaspace', 'audaspace Documentation',
+     ['Jörg Müller'], 1)
+]
+
+# If true, show URL addresses after external links.
+#man_show_urls = False
+
+
+# -- Options for Texinfo output -------------------------------------------
+
+# Grouping the document tree into Texinfo files. List of tuples
+# (source start file, target name, title, author,
+#  dir menu entry, description, category)
+texinfo_documents = [
+  ('index', 'audaspace', 'audaspace Documentation',
+   'Jörg Müller', 'audaspace', 'One line description of project.',
+   'Miscellaneous'),
+]
+
+# Documents to append as an appendix to all manuals.
+#texinfo_appendices = []
+
+# If false, no module index is generated.
+#texinfo_domain_indices = True
+
+# How to display URL addresses: 'footnote', 'no', or 'inline'.
+#texinfo_show_urls = 'footnote'
+
+# If true, do not generate a @detailmenu in the "Top" node's menu.
+#texinfo_no_detailmenu = False

blender-5.2.0/extern/audaspace/bindings/doc/device.rst

@@ -0,0 +1,8 @@
+Device
+======
+
+.. currentmodule:: aud
+.. autoclass:: Device
+   :members:
+   :noindex:
+

blender-5.2.0/extern/audaspace/bindings/doc/handle.rst

@@ -0,0 +1,8 @@
+Handle
+======
+
+.. currentmodule:: aud
+.. autoclass:: Handle
+   :members:
+   :noindex:
+

blender-5.2.0/extern/audaspace/bindings/doc/index.rst

@@ -0,0 +1,36 @@
+.. audaspace documentation master file, created by
+   sphinx-quickstart on Tue Sep  9 01:48:48 2014.
+   You can adapt this file completely to your liking, but it should at least
+   contain the root `toctree` directive.
+
+Welcome to audaspace's documentation!
+=====================================
+
+.. automodule:: aud
+   :no-members:
+
+This documentation is valid for both the Python and C bindings of audaspace. If you are looking for installation instructions check the `C++ API documentation <../index.html>`_. As C is not an object oriented language everything is accessible via functions where the first paramter is always the object. For methods these are named as ``AUD_ClassName_method()`` and properties are accessed via ``AUD_ClassName_property_get/set()``. Python users simply ``import aud`` to access the library.
+
+.. toctree::
+   :maxdepth: 2
+
+   tutorials
+
+Classes:
+
+.. toctree::
+   :maxdepth: 1
+
+   device
+   sound
+   handle
+   sequence
+   sequence_entry
+
+Indices and tables
+==================
+
+* :ref:`genindex`
+* :ref:`modindex`
+* :ref:`search`
+

blender-5.2.0/extern/audaspace/bindings/doc/sequence.rst

@@ -0,0 +1,8 @@
+Sequence
+========
+
+.. currentmodule:: aud
+.. autoclass:: Sequence
+   :members:
+   :noindex:
+

blender-5.2.0/extern/audaspace/bindings/doc/sequence_entry.rst

@@ -0,0 +1,8 @@
+Sequence Entry
+==============
+
+.. currentmodule:: aud
+.. autoclass:: SequenceEntry
+   :members:
+   :noindex:
+

blender-5.2.0/extern/audaspace/bindings/doc/sound.rst

@@ -0,0 +1,8 @@
+Sound
+=====
+
+.. currentmodule:: aud
+.. autoclass:: Sound
+   :members:
+   :noindex:
+

blender-5.2.0/extern/audaspace/bindings/doc/tutorials.rst

@@ -0,0 +1,240 @@
+Tutorials
+=========
+
+Introduction
+------------
+
+The C and Python binding for audaspace were designed with simplicity in mind.
+This means however that to use the full capabilities of audaspace,
+there is no way around the C++ library.
+
+Simple Demo
+-----------
+
+The **simple.py** example program contains all the basic
+building blocks for an application using audaspace.
+These building blocks are basically the classes :class:`aud.Device`,
+:class:`aud.Sound` and :class:`aud.Handle`.
+
+We start with importing :mod:`aud` and :mod:`time`
+as the modules we need for our simple example.
+
+.. code-block:: python
+
+   #!/usr/bin/python
+   import aud, time
+
+The first step now is to open an output device and this
+can simply be done by allocating a :class:`aud.Device` object.
+
+.. code-block:: python
+
+   device = aud.Device()
+
+To create a sound we can choose to load one from a :func:`aud.Sound.file`,
+or we use one of our signal generators. We decide to do the latter
+and create a :func:`aud.Sound.sine` signal with a frequency of 440 Hz.
+
+.. code-block:: python
+
+   sine = aud.Sound.sine(440)
+
+.. note:: At this point nothing is playing back yet,
+   :class:`aud.Sound` objects are just descriptions of sounds.
+
+However instead of a sine wave, we would like to have a square wave
+to produce a more retro gaming sound. We could of course use the
+:func:`aud.Sound.square` generator instead of sine,
+but we want to show how to apply effects,
+so we apply a :func:`aud.Sound.threshold`
+which makes a square wave out of our sine too,
+even if less efficient than directly generating the square wave.
+
+.. code-block:: python
+
+   square = sine.threshold()
+
+.. note:: The :class:`aud.Sound` class offers generator and effect functions.
+
+The we can play our sound by calling the
+:func:`aud.Device.play` method of our device.
+This method returns a :class:`aud.Handle`
+which is used to control the playback of the sound.
+
+.. code-block:: python
+
+   handle = device.play(square)
+
+Now if we do nothing else anymore the application will quit immediately,
+so we won't hear much of our square wave,
+so we decide to wait for three seconds before
+quitting the application by calling :func:`time.sleep`.
+
+.. code-block:: python
+
+   time.sleep(3)
+
+Audioplayer
+-----------
+
+Now that we know the basics of audaspace,
+we can build our own music player easily
+by just slightly changing the previous program.
+The **player.py** example does exactly that,
+let's have a short look at the differences:
+
+Instead of creating a sine signal and thresholding it,
+we in fact use the :func:`aud.Sound.file` function to load a sound from a file.
+The filename we pass is the first command line argument our application got.
+
+.. code-block:: python
+
+   sound = aud.Sound.file(sys.argv[1])
+
+When the sound gets played back we now want to wait until
+the whole file has been played, so we use the :data:`aud.Handle.status`
+property to determine whether the sound finished playing.
+
+.. code-block:: python
+
+   while handle.status:
+   	time.sleep(0.1)
+
+We don't make any error checks if the user actually added a command
+line argument. As an exercise you could extend this program to play
+any number of command line supplied files in sequence.
+
+Siren
+-----
+
+Let's get a little bit more complex. The **siren.py** example
+plays a generated siren sound that circles around your head.
+Depending on how many speakers you have and if the output
+device used supports the speaker setup, you will hear this effect.
+With stereo speakers you should at least hear some left-right-panning.
+
+We start off again with importing the modules we need and
+we also define some properties of our siren sound.
+We want it to consist of two sine sounds with different frequencies.
+We define a length for the sine sounds and how long a fade in/out should take.
+We also know already how to open a device.
+
+.. code-block:: python
+
+   #!/usr/bin/python
+   import aud, math, time
+   length = 0.5
+   fadelength = 0.05
+
+   device = aud.Device()
+
+The next thing to do is to define our sine waves and apply all the required effects.
+As each of the effect functions returns the corresponding sound,
+we can easily chain those calls together.
+
+.. code-block:: python
+
+   high = aud.Sound.sine(880).limit(0, length).fadein(0, fadelength).fadeout(length - fadelength, length)
+   low = aud.Sound.sine(700).limit(0, length).fadein(0, fadelength).fadeout(length - fadelength, length).volume(0.6)
+
+The next step is to connect the two sines,
+which we do using the :func:`aud.Sound.join` function.
+
+.. code-block:: python
+
+   sound = high.join(low)
+
+The generated siren sound can now be played back and what we also do is to loop it.
+Therefore we set the :data:`aud.Handle.loop_count` to a negative value to loop forever.
+
+.. code-block:: python
+
+   handle = device.play(sound)
+   handle.loop_count = -1
+
+Now we use some timing code to make sure our demo runs for 10 seconds,
+but we also use the time to update the location of our playing sound,
+with the :data:`aud.Handle.location` property, which is a three dimensional vector.
+The trigonometic calculation based on the running time of the program keeps
+the sound on the XZ plane letting it follow a circle around us.
+
+.. code-block:: python
+
+   start = time.time()
+
+   while time.time() - start < 10:
+   	angle = time.time() - start
+
+   	handle.location = [math.sin(angle), 0, -math.cos(angle)]
+
+As an exercise you could try to let the sound come from the far left
+and go to the far right and a little bit in front of you within the
+10 second runtime of the program. With this change you should be able
+to hear the volume of the sound change, depending on how far it is away from you.
+Updating the :data:`aud.Handle.velocity` property properly also enables the doppler effect.
+Compare your solution to the **siren2.py** demo.
+
+Tetris
+------
+
+The **tetris.py** demo application shows an even more
+complex application which generates retro tetris music.
+Looking at the source code there should be nothing new here,
+again the functions used from audaspace are the same as in the previous examples.
+In the :func:`parseNote` function all single notes get joined which leads
+to a very long chain of sounds. If you think of :func:`aud.Sound.join`
+as a function that creates a binary tree with the two joined sounds as
+leaves then the :func:`parseNote` function creates a very unbalanced tree.
+
+Insted we could rewrite the code to use two other classes:
+:class:`aud.Sequence` and :class:`aud.SequenceEntry` to sequence the notes.
+The **tetris2.py** application does exactly that.
+Before the while loop we add a variable that stores the current position
+in the score and create a new :class:`aud.Sequence` object.
+
+.. code-block:: python
+
+   position = 0
+   sequence = aud.Sequence()
+
+Then in the loop we can create the note simply by chaining the
+:func:`aud.Sound.square` generator and :func:`aud.Sound.fadein`
+and :func:`aud.Sound.fadeout` effects.
+
+.. code-block:: python
+
+   note = aud.Sound.square(freq, rate).fadein(0, fadelength).fadeout(length - fadelength, fadelength)
+
+Now instead of using :func:`aud.Sound.limit` and :func:`aud.Sound.join`
+we simply add the sound to the sequence.
+
+.. code-block:: python
+
+   entry = sequence.add(note, position, position + length, 0)
+
+The entry returned from the :func:`aud.Sequence.add`
+function is an object of the :class:`aud.SequenceEntry` class.
+We can use this entry to mute the note in case it's actually a pause.
+
+.. code-block:: python
+
+   if char == 'p':
+   	entry.muted = True
+
+Lastly we have to update our position variable.
+
+.. code-block:: python
+
+   position += length
+
+Now in **tetris2.py** we used the :data:`aud.SequenceEntry.muted`
+property to show how the :class:`aud.SequenceEntry` class can be used,
+but it would actually be smarter to not even create a note for pauses and just skip them.
+You can try to implement this as an exercise and then check out the solution in **tetris3.py**.
+
+Conclusion
+----------
+
+We introduced all five currently available classes in the audaspace Python API.
+Of course all classes offer a lot more functions than have been used in these demo applications,
+check out the specific class documentation for more details.

blender-5.2.0/extern/audaspace/bindings/python/PyAPI.cpp

@@ -0,0 +1,249 @@
+/*******************************************************************************
+ * 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 "PyAnimateableProperty.h"
+#include "PyAPI.h"
+#include "PySound.h"
+#include "PyHandle.h"
+#include "PyDevice.h"
+#include "PySequenceEntry.h"
+#include "PySequence.h"
+#include "PyPlaybackManager.h"
+#include "PyDynamicMusic.h"
+#include "PyThreadPool.h"
+#include "PySource.h"
+
+#ifdef WITH_CONVOLUTION
+#include "PyImpulseResponse.h"
+#include "PyHRTF.h"
+#endif
+
+#ifdef WITH_RUBBERBAND
+#include "fx/TimeStretchPitchScale.h"
+#endif
+
+#include "respec/Specification.h"
+#include "devices/IHandle.h"
+#include "devices/I3DDevice.h"
+#include "file/IWriter.h"
+#include "plugin/PluginManager.h"
+#include "sequence/AnimateableProperty.h"
+#include "ISound.h"
+
+#include <memory>
+
+#include <structmember.h>
+
+using namespace aud;
+// ====================================================================
+
+#define PY_MODULE_ADD_CONSTANT(module, name) PyModule_AddIntConstant(module, #name, name)
+
+// ====================================================================
+
+extern PyObject* AUDError;
+PyObject* AUDError = nullptr;
+
+// ====================================================================
+
+PyDoc_STRVAR(M_aud_doc,
+			 "Audaspace (pronounced \"outer space\") is a high level audio library.");
+
+static struct PyModuleDef audmodule = {
+	PyModuleDef_HEAD_INIT,
+	"aud",     /* name of module */
+	M_aud_doc, /* module documentation */
+	-1,        /* size of per-interpreter state of the module,
+				  or -1 if the module keeps state in global variables. */
+   nullptr, nullptr, nullptr, nullptr, nullptr
+};
+
+PyMODINIT_FUNC
+PyInit_aud()
+{
+	PyObject* module;
+
+	PluginManager::loadPlugins();
+
+	if(!initializeSound())
+		return nullptr;
+
+	if(!initializeDevice())
+		return nullptr;
+
+	if(!initializeHandle())
+		return nullptr;
+
+	if(!initializeSequenceEntry())
+		return nullptr;
+
+	if(!initializeSequence())
+		return nullptr;
+
+	if(!initializeDynamicMusic())
+		return nullptr;
+
+	if(!initializePlaybackManager())
+		return nullptr;
+
+	if(!initializeThreadPool())
+		return nullptr;
+
+	if(!initializeSource())
+		return nullptr;
+
+	if(!initializeAnimateableProperty())
+		return nullptr;
+
+#ifdef WITH_CONVOLUTION
+	if(!initializeImpulseResponse())
+		return nullptr;
+
+	if(!initializeHRTF())
+		return nullptr;
+#endif
+
+	module = PyModule_Create(&audmodule);
+	if(module == nullptr)
+		return nullptr;
+
+	addAnimateablePropertyToModule(module);
+	addSoundToModule(module);
+	addHandleToModule(module);
+	addDeviceToModule(module);
+	addSequenceEntryToModule(module);
+	addSequenceToModule(module);
+	addDynamicMusicToModule(module);
+	addPlaybackManagerToModule(module);
+	addThreadPoolToModule(module);
+	addSourceToModule(module);
+
+#ifdef WITH_CONVOLUTION
+	addImpulseResponseToModule(module);
+	addHRTFToModule(module);
+#endif
+
+	AUDError = PyErr_NewException("aud.error", nullptr, nullptr);
+	Py_INCREF(AUDError);
+	PyModule_AddObject(module, "error", AUDError);
+
+	// animatable property type constants
+	PY_MODULE_ADD_CONSTANT(module, AP_VOLUME);
+	PY_MODULE_ADD_CONSTANT(module, AP_PANNING);
+	PY_MODULE_ADD_CONSTANT(module, AP_PITCH);
+	PY_MODULE_ADD_CONSTANT(module, AP_LOCATION);
+	PY_MODULE_ADD_CONSTANT(module, AP_ORIENTATION);
+	PY_MODULE_ADD_CONSTANT(module, AP_TIME_STRETCH);
+	PY_MODULE_ADD_CONSTANT(module, AP_PITCH_SCALE);
+	// channels constants
+	PY_MODULE_ADD_CONSTANT(module, CHANNELS_INVALID);
+	PY_MODULE_ADD_CONSTANT(module, CHANNELS_MONO);
+	PY_MODULE_ADD_CONSTANT(module, CHANNELS_STEREO);
+	PY_MODULE_ADD_CONSTANT(module, CHANNELS_STEREO_LFE);
+	PY_MODULE_ADD_CONSTANT(module, CHANNELS_SURROUND4);
+	PY_MODULE_ADD_CONSTANT(module, CHANNELS_SURROUND5);
+	PY_MODULE_ADD_CONSTANT(module, CHANNELS_SURROUND51);
+	PY_MODULE_ADD_CONSTANT(module, CHANNELS_SURROUND61);
+	PY_MODULE_ADD_CONSTANT(module, CHANNELS_SURROUND71);
+	// codec constants
+	PY_MODULE_ADD_CONSTANT(module, CODEC_INVALID);
+	PY_MODULE_ADD_CONSTANT(module, CODEC_AAC);
+	PY_MODULE_ADD_CONSTANT(module, CODEC_AC3);
+	PY_MODULE_ADD_CONSTANT(module, CODEC_FLAC);
+	PY_MODULE_ADD_CONSTANT(module, CODEC_MP2);
+	PY_MODULE_ADD_CONSTANT(module, CODEC_MP3);
+	PY_MODULE_ADD_CONSTANT(module, CODEC_PCM);
+	PY_MODULE_ADD_CONSTANT(module, CODEC_VORBIS);
+	PY_MODULE_ADD_CONSTANT(module, CODEC_OPUS);
+	// container constants
+	PY_MODULE_ADD_CONSTANT(module, CONTAINER_INVALID);
+	PY_MODULE_ADD_CONSTANT(module, CONTAINER_AC3);
+	PY_MODULE_ADD_CONSTANT(module, CONTAINER_FLAC);
+	PY_MODULE_ADD_CONSTANT(module, CONTAINER_MATROSKA);
+	PY_MODULE_ADD_CONSTANT(module, CONTAINER_MP2);
+	PY_MODULE_ADD_CONSTANT(module, CONTAINER_MP3);
+	PY_MODULE_ADD_CONSTANT(module, CONTAINER_OGG);
+	PY_MODULE_ADD_CONSTANT(module, CONTAINER_WAV);
+	PY_MODULE_ADD_CONSTANT(module, CONTAINER_AAC);
+	// distance model constants
+	PY_MODULE_ADD_CONSTANT(module, DISTANCE_MODEL_EXPONENT);
+	PY_MODULE_ADD_CONSTANT(module, DISTANCE_MODEL_EXPONENT_CLAMPED);
+	PY_MODULE_ADD_CONSTANT(module, DISTANCE_MODEL_INVERSE);
+	PY_MODULE_ADD_CONSTANT(module, DISTANCE_MODEL_INVERSE_CLAMPED);
+	PY_MODULE_ADD_CONSTANT(module, DISTANCE_MODEL_LINEAR);
+	PY_MODULE_ADD_CONSTANT(module, DISTANCE_MODEL_LINEAR_CLAMPED);
+	PY_MODULE_ADD_CONSTANT(module, DISTANCE_MODEL_INVALID);
+	// format constants
+	PY_MODULE_ADD_CONSTANT(module, FORMAT_INVALID);
+	PY_MODULE_ADD_CONSTANT(module, FORMAT_FLOAT32);
+	PY_MODULE_ADD_CONSTANT(module, FORMAT_FLOAT64);
+	PY_MODULE_ADD_CONSTANT(module, FORMAT_INVALID);
+	PY_MODULE_ADD_CONSTANT(module, FORMAT_S16);
+	PY_MODULE_ADD_CONSTANT(module, FORMAT_S24);
+	PY_MODULE_ADD_CONSTANT(module, FORMAT_S32);
+	PY_MODULE_ADD_CONSTANT(module, FORMAT_U8);
+	// rate constants
+	PY_MODULE_ADD_CONSTANT(module, RATE_INVALID);
+	PY_MODULE_ADD_CONSTANT(module, RATE_8000);
+	PY_MODULE_ADD_CONSTANT(module, RATE_16000);
+	PY_MODULE_ADD_CONSTANT(module, RATE_11025);
+	PY_MODULE_ADD_CONSTANT(module, RATE_22050);
+	PY_MODULE_ADD_CONSTANT(module, RATE_32000);
+	PY_MODULE_ADD_CONSTANT(module, RATE_44100);
+	PY_MODULE_ADD_CONSTANT(module, RATE_48000);
+	PY_MODULE_ADD_CONSTANT(module, RATE_88200);
+	PY_MODULE_ADD_CONSTANT(module, RATE_96000);
+	PY_MODULE_ADD_CONSTANT(module, RATE_192000);
+	// status constants
+	PY_MODULE_ADD_CONSTANT(module, STATUS_INVALID);
+	PY_MODULE_ADD_CONSTANT(module, STATUS_PAUSED);
+	PY_MODULE_ADD_CONSTANT(module, STATUS_PLAYING);
+	PY_MODULE_ADD_CONSTANT(module, STATUS_STOPPED);
+
+#ifdef WITH_RUBBERBAND
+	// stretcher quality
+	PyModule_AddIntConstant(module, "STRETCHER_QUALITY_HIGH", static_cast<int>(StretcherQuality::HIGH));
+	PyModule_AddIntConstant(module, "STRETCHER_QUALITY_FAST", static_cast<int>(StretcherQuality::FAST));
+	PyModule_AddIntConstant(module, "STRETCHER_QUALITY_CONSISTENT", static_cast<int>(StretcherQuality::CONSISTENT));
+#endif
+
+	return module;
+}
+
+AUD_API PyObject* AUD_getPythonSound(void* sound)
+{
+	if(sound)
+	{
+		Sound* object = (Sound*) Sound_empty();
+		if(object)
+		{
+			object->sound = new std::shared_ptr<ISound>(*reinterpret_cast<std::shared_ptr<ISound>*>(sound));
+			return (PyObject *) object;
+		}
+	}
+
+	return nullptr;
+}
+
+AUD_API void* AUD_getSoundFromPython(PyObject* object)
+{
+	Sound* sound = checkSound(object);
+
+	if(!sound)
+		return nullptr;
+
+	return new std::shared_ptr<ISound>(*reinterpret_cast<std::shared_ptr<ISound>*>(sound->sound));
+}

blender-5.2.0/extern/audaspace/bindings/python/PyAPI.h

@@ -0,0 +1,45 @@
+/*******************************************************************************
+ * 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.
+ ******************************************************************************/
+
+#pragma once
+
+#include <Python.h>
+#include "Audaspace.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyMODINIT_FUNC
+PyInit_aud();
+
+/**
+ * Retrieves the python factory of a sound.
+ * \param sound The sound factory.
+ * \return The python factory.
+ */
+extern AUD_API PyObject* AUD_getPythonSound(void* sound);
+
+/**
+ * Retrieves the sound factory of a python factory.
+ * \param sound The python factory.
+ * \return The sound factory.
+ */
+extern AUD_API void* AUD_getSoundFromPython(PyObject* object);
+
+#ifdef __cplusplus
+}
+#endif

blender-5.2.0/extern/audaspace/bindings/python/PyAnimateableProperty.cpp

@@ -0,0 +1,404 @@
+/*******************************************************************************
+ * Copyright 2009-2025 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 "PyAnimateableProperty.h"
+
+#include "Exception.h"
+
+#include "sequence/AnimateableProperty.h"
+
+#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
+#include <memory>
+
+#include <numpy/ndarrayobject.h>
+
+using namespace aud;
+
+extern PyObject* AUDError;
+
+static PyObject* AnimateableProperty_new(PyTypeObject* type, PyObject* args, PyObject* kwds)
+{
+	AnimateablePropertyP* self = (AnimateablePropertyP*) type->tp_alloc(type, 0);
+
+	int count;
+	float value;
+
+	if(self != nullptr)
+	{
+		if(!PyArg_ParseTuple(args, "i|f:animateableProperty", &count, &value))
+			return nullptr;
+
+		try
+		{
+			if(PyTuple_Size(args) == 1)
+			{
+				self->animateableProperty = new std::shared_ptr<aud::AnimateableProperty>(new aud::AnimateableProperty(count));
+			}
+			else
+			{
+				self->animateableProperty = new std::shared_ptr<aud::AnimateableProperty>(new aud::AnimateableProperty(count, value));
+			}
+		}
+		catch(aud::Exception& e)
+		{
+			Py_DECREF(self);
+			PyErr_SetString(AUDError, e.what());
+			return nullptr;
+		}
+	}
+
+	return (PyObject*) self;
+}
+
+static void AnimateableProperty_dealloc(AnimateablePropertyP* self)
+{
+	if(self->animateableProperty)
+		delete reinterpret_cast<std::shared_ptr<aud::AnimateableProperty>*>(self->animateableProperty);
+	Py_TYPE(self)->tp_free((PyObject*) self);
+}
+
+static PyObject* AnimateableProperty_read(AnimateablePropertyP* self, PyObject* args)
+{
+	float position;
+
+	if(!PyArg_ParseTuple(args, "f", &position))
+		return nullptr;
+
+	int count = (*reinterpret_cast<std::shared_ptr<aud::AnimateableProperty>*>(self->animateableProperty))->getCount();
+	npy_intp dims[1] = {count};
+	PyObject* np_array = PyArray_SimpleNew(1, dims, NPY_FLOAT32);
+	if(!np_array)
+		return nullptr;
+
+	float* out = static_cast<float*>(PyArray_DATA(reinterpret_cast<PyArrayObject*>(np_array)));
+
+	try
+	{
+		(*reinterpret_cast<std::shared_ptr<aud::AnimateableProperty>*>(self->animateableProperty))->read(position, out);
+		return np_array;
+	}
+	catch(aud::Exception& e)
+	{
+		Py_DECREF(np_array);
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+PyDoc_STRVAR(M_aud_AnimateableProperty_read_doc, ".. method:: read(position)\n\n"
+                                                 "   Reads the properties value at the given position.\n\n"
+                                                 "   :param position: The position in the animation in frames.\n"
+                                                 "   :type position: float\n"
+                                                 "   :return: A numpy array of values representing the properties value.\n"
+                                                 "   :rtype: :class:`numpy.ndarray`\n");
+
+static PyObject* AnimateableProperty_readSingle(AnimateablePropertyP* self, PyObject* args)
+{
+	float position;
+
+	if(!PyArg_ParseTuple(args, "f", &position))
+		return nullptr;
+
+	try
+	{
+		float value = (*reinterpret_cast<std::shared_ptr<aud::AnimateableProperty>*>(self->animateableProperty))->readSingle(position);
+		return Py_BuildValue("f", value);
+	}
+	catch(aud::Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+PyDoc_STRVAR(M_aud_AnimateableProperty_readSingle_doc, ".. method:: readSingle(position)\n\n"
+                                                       "   Reads the properties value at the given position, assuming there is exactly one value.\n\n"
+                                                       "   :param position: The position in the animation in frames.\n"
+                                                       "   :type position: float\n"
+                                                       "   :return: The value at that position.\n"
+                                                       "   :rtype: float\n\n");
+
+static PyObject* AnimateableProperty_write(AnimateablePropertyP* self, PyObject* args)
+{
+	PyObject* array_obj;
+	int position = -1;
+
+	if(!PyArg_ParseTuple(args, "O|i", &array_obj, &position))
+		return nullptr;
+
+	PyArrayObject* np_array = reinterpret_cast<PyArrayObject*>(PyArray_FROM_OTF(array_obj, NPY_FLOAT32, NPY_ARRAY_IN_ARRAY | NPY_ARRAY_FORCECAST));
+
+	if(!np_array)
+	{
+		PyErr_SetString(PyExc_TypeError, "data must be a numpy array of dtype float32");
+		return nullptr;
+	}
+
+	auto& prop = *reinterpret_cast<std::shared_ptr<aud::AnimateableProperty>*>(self->animateableProperty);
+	int prop_count = prop->getCount();
+	npy_intp size = PyArray_SIZE(np_array);
+
+	int ndim = PyArray_NDIM(np_array);
+
+	bool valid_shape = false;
+
+	// For 1D arrays, the total number of elements must be a multiple of the property count
+	if(ndim == 1)
+	{
+		valid_shape = (size % prop_count == 0);
+	}
+	// For 2D arrays, the number of elements in the second dimension must be the property count
+	else if(ndim == 2)
+	{
+		npy_intp* shape = PyArray_DIMS(np_array);
+		valid_shape = (shape[1] == prop_count);
+	}
+
+	if(!valid_shape)
+	{
+		PyErr_SetString(PyExc_ValueError, "array shape is invalid: must be 1D with length multiple of property count or 2D with the last dimension equal to property count");
+		Py_DECREF(np_array);
+		return nullptr;
+	}
+
+	int count = static_cast<int>(size / prop_count);
+
+	if(count < 1)
+	{
+		PyErr_SetString(PyExc_ValueError, "input array must have at least 1 element");
+		Py_DECREF(np_array);
+		return nullptr;
+	}
+
+	float* data_ptr = reinterpret_cast<float*>(PyArray_DATA(np_array));
+	try
+	{
+		if(position == -1)
+		{
+			if(count != 1)
+			{
+				PyErr_SetString(PyExc_ValueError, "input array must have exactly 1 element when position is not specified");
+				Py_DECREF(np_array);
+				return nullptr;
+			}
+			prop->write(data_ptr);
+		}
+		else
+		{
+			prop->write(data_ptr, position, count);
+		}
+	}
+	catch(aud::Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+	}
+
+	Py_DECREF(np_array);
+	Py_RETURN_NONE;
+}
+
+PyDoc_STRVAR(M_aud_AnimateableProperty_write_doc, ".. method:: write(data[, position])\n\n"
+                                                  "   Writes the properties value.\n\n"
+                                                  "   If `position` is also given, the property is marked animated and\n"
+                                                  "   the values are written starting at `position`.\n\n"
+                                                  "   :param data: numpy array of float32 values.\n"
+                                                  "   :type data: numpy.ndarray\n"
+                                                  "   :param position: The starting position in frames.\n"
+                                                  "   :type position: int\n\n");
+
+static PyObject* AnimateableProperty_writeConstantRange(AnimateablePropertyP* self, PyObject* args)
+{
+	PyObject* array_obj;
+	int position_start;
+	int position_end;
+
+	if(!PyArg_ParseTuple(args, "Oii", &array_obj, &position_start, &position_end))
+		return nullptr;
+
+	PyArrayObject* np_array = reinterpret_cast<PyArrayObject*>(PyArray_FROM_OTF(array_obj, NPY_FLOAT32, NPY_ARRAY_IN_ARRAY | NPY_ARRAY_FORCECAST));
+	if(!np_array)
+	{
+		PyErr_SetString(PyExc_TypeError, "data must be a numpy array of dtype float32");
+		return nullptr;
+	}
+
+	int ndim = PyArray_NDIM(np_array);
+	if(ndim != 1)
+	{
+		PyErr_SetString(PyExc_ValueError, "data must be a 1D numpy array");
+		Py_DECREF(np_array);
+		return nullptr;
+	}
+
+	float* data_ptr = reinterpret_cast<float*>(PyArray_DATA(np_array));
+
+	auto& prop = *reinterpret_cast<std::shared_ptr<aud::AnimateableProperty>*>(self->animateableProperty);
+	int prop_count = prop->getCount();
+
+	npy_intp size = PyArray_SIZE(np_array);
+
+	if(size != prop_count)
+	{
+		PyErr_Format(PyExc_ValueError, "input array length (%lld) does not match property count (%d)", size, prop_count);
+		Py_DECREF(np_array);
+		return nullptr;
+	}
+
+	try
+	{
+		prop->writeConstantRange(data_ptr, position_start, position_end);
+	}
+	catch(aud::Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+
+	Py_DECREF(np_array);
+	Py_RETURN_NONE;
+}
+
+PyDoc_STRVAR(M_aud_AnimateableProperty_writeConstantRange_doc, ".. method:: writeConstantRange(data, position_start, position_end)\n\n"
+                                                               "   Fills the properties frame range with a constant value and marks it animated.\n\n"
+                                                               "   :param data: numpy array of float values representing the constant value.\n"
+                                                               "   :type data: numpy.ndarray\n"
+                                                               "   :param position_start: The start position in frames.\n"
+                                                               "   :type position_start: int\n"
+                                                               "   :param position_end: The end position in frames.\n"
+                                                               "   :type position_end: int\n\n");
+
+static PyMethodDef AnimateableProperty_methods[] = {
+
+    {(char*) "read", (PyCFunction) AnimateableProperty_read, METH_VARARGS, M_aud_AnimateableProperty_read_doc},
+    {(char*) "readSingle", (PyCFunction) AnimateableProperty_readSingle, METH_VARARGS, M_aud_AnimateableProperty_readSingle_doc},
+    {(char*) "write", (PyCFunction) AnimateableProperty_write, METH_VARARGS, M_aud_AnimateableProperty_write_doc},
+    {(char*) "writeConstantRange", (PyCFunction) AnimateableProperty_writeConstantRange, METH_VARARGS, M_aud_AnimateableProperty_writeConstantRange_doc},
+    {nullptr} /* Sentinel */
+};
+
+static PyObject* AnimateableProperty_get_count(AnimateablePropertyP* self, void* nothing)
+{
+	try
+	{
+		int count = (*reinterpret_cast<std::shared_ptr<aud::AnimateableProperty>*>(self->animateableProperty))->getCount();
+		return Py_BuildValue("i", count);
+	}
+	catch(aud::Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+PyDoc_STRVAR(M_aud_AnimateableProperty_count_doc, "The count of floats for a property.");
+
+static PyObject* AnimateableProperty_get_animated(AnimateablePropertyP* self, void* nothing)
+{
+	try
+	{
+		bool animated = (*reinterpret_cast<std::shared_ptr<aud::AnimateableProperty>*>(self->animateableProperty))->isAnimated();
+		return PyBool_FromLong(animated);
+	}
+	catch(aud::Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+PyDoc_STRVAR(M_aud_AnimateableProperty_animated_doc, "Whether the property is animated.");
+
+static PyGetSetDef AnimateableProperty_properties[] = {
+    {(char*) "count", (getter) AnimateableProperty_get_count, nullptr, M_aud_AnimateableProperty_count_doc, nullptr},
+    {(char*) "animated", (getter) AnimateableProperty_get_animated, nullptr, M_aud_AnimateableProperty_animated_doc, nullptr},
+    {nullptr} /* Sentinel */
+};
+
+PyDoc_STRVAR(M_aud_AnimateableProperty_doc,
+	".. class:: AnimateableProperty(count, value=0.0, /)\n\n"
+	"   An AnimateableProperty object stores an array of float values for animating sound properties (e.g. pan, volume, pitch-scale).\n\n"
+	"   :arg count: The number of float values to store per frame.\n"
+	"   :type count: int\n"
+	"   :arg value: The initial value for all elements.\n"
+	"   :type value: float\n");
+
+// Note that AnimateablePropertyType name is already taken
+PyTypeObject AnimateablePropertyPyType = {
+    PyVarObject_HEAD_INIT(nullptr, 0) "aud.AnimateableProperty", /* tp_name */
+    sizeof(AnimateablePropertyP),                                /* tp_basicsize */
+    0,                                                           /* tp_itemsize */
+    (destructor) AnimateableProperty_dealloc,                    /* tp_dealloc */
+    0,                                                           /* tp_print */
+    0,                                                           /* tp_getattr */
+    0,                                                           /* tp_setattr */
+    0,                                                           /* tp_reserved */
+    0,                                                           /* tp_repr */
+    0,                                                           /* tp_as_number */
+    0,                                                           /* tp_as_sequence */
+    0,                                                           /* tp_as_mapping */
+    0,                                                           /* tp_hash  */
+    0,                                                           /* tp_call */
+    0,                                                           /* tp_str */
+    0,                                                           /* tp_getattro */
+    0,                                                           /* tp_setattro */
+    0,                                                           /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT,                                          /* tp_flags */
+    M_aud_AnimateableProperty_doc,                               /* tp_doc */
+    0,                                                           /* tp_traverse */
+    0,                                                           /* tp_clear */
+    0,                                                           /* tp_richcompare */
+    0,                                                           /* tp_weaklistoffset */
+    0,                                                           /* tp_iter */
+    0,                                                           /* tp_iternext */
+    AnimateableProperty_methods,                                 /* tp_methods */
+    0,                                                           /* tp_members */
+    AnimateableProperty_properties,                              /* tp_getset */
+    0,                                                           /* tp_base */
+    0,                                                           /* tp_dict */
+    0,                                                           /* tp_descr_get */
+    0,                                                           /* tp_descr_set */
+    0,                                                           /* tp_dictoffset */
+    0,                                                           /* tp_init */
+    0,                                                           /* tp_alloc */
+    AnimateableProperty_new,                                     /* tp_new */
+};
+
+AUD_API PyObject* AnimateableProperty_empty()
+{
+	return AnimateablePropertyPyType.tp_alloc(&AnimateablePropertyPyType, 0);
+}
+
+AUD_API AnimateablePropertyP* checkAnimateableProperty(PyObject* animateableProperty)
+{
+	if(!PyObject_TypeCheck(animateableProperty, &AnimateablePropertyPyType))
+	{
+		PyErr_SetString(PyExc_TypeError, "Object is not of type AnimateableProperty!");
+		return nullptr;
+	}
+
+	return (AnimateablePropertyP*) animateableProperty;
+}
+
+bool initializeAnimateableProperty()
+{
+	import_array1(false);
+	return PyType_Ready(&AnimateablePropertyPyType) >= 0;
+}
+
+void addAnimateablePropertyToModule(PyObject* module)
+{
+	Py_INCREF(&AnimateablePropertyPyType);
+	PyModule_AddObject(module, "AnimateableProperty", (PyObject*) &AnimateablePropertyPyType);
+}

blender-5.2.0/extern/audaspace/bindings/python/PyAnimateableProperty.h

@@ -0,0 +1,34 @@
+/*******************************************************************************
+ * Copyright 2009-2025 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.
+ ******************************************************************************/
+
+#pragma once
+
+#include <Python.h>
+
+#include "Audaspace.h"
+
+typedef void Reference_AnimateableProperty;
+
+typedef struct
+{
+	PyObject_HEAD Reference_AnimateableProperty* animateableProperty;
+} AnimateablePropertyP;
+
+extern AUD_API PyObject* AnimateableProperty_empty();
+extern AUD_API AnimateablePropertyP* checkAnimateableProperty(PyObject* animateableProperty);
+
+bool initializeAnimateableProperty();
+void addAnimateablePropertyToModule(PyObject* module);

blender-5.2.0/extern/audaspace/bindings/python/PyDevice.cpp

@@ -0,0 +1,800 @@
+/*******************************************************************************
+ * 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 "PyDevice.h"
+
+#include "PySound.h"
+#include "PyHandle.h"
+
+#include "Exception.h"
+#include "devices/IDevice.h"
+#include "devices/I3DDevice.h"
+#include "devices/DeviceManager.h"
+#include "devices/IDeviceFactory.h"
+
+#include <structmember.h>
+
+using namespace aud;
+
+extern PyObject* AUDError;
+static const char* device_not_3d_error = "Device is not a 3D device!";
+
+// ====================================================================
+
+static void
+Device_dealloc(Device* self)
+{
+	if(self->device)
+		delete reinterpret_cast<std::shared_ptr<IDevice>*>(self->device);
+	Py_TYPE(self)->tp_free((PyObject *)self);
+}
+
+static PyObject *
+Device_new(PyTypeObject* type, PyObject* args, PyObject* kwds)
+{
+	Device* self;
+
+	static const char* kwlist[] = {"type", "rate", "channels", "format", "buffer_size", "name", nullptr};
+	const char* device = nullptr;
+	double rate = RATE_48000;
+	int channels = CHANNELS_STEREO;
+	int format = FORMAT_FLOAT32;
+	int buffersize = AUD_DEFAULT_BUFFER_SIZE;
+	const char* name = "";
+
+	if(!PyArg_ParseTupleAndKeywords(args, kwds, "|sdiiis:Device", const_cast<char**>(kwlist),
+									&device, &rate, &channels, &format, &buffersize, &name))
+		return nullptr;
+
+	if(buffersize < 128)
+	{
+		PyErr_SetString(PyExc_ValueError, "buffer_size must be at least 128!");
+		return nullptr;
+	}
+
+	self = (Device*)type->tp_alloc(type, 0);
+
+	if(self != nullptr)
+	{
+		DeviceSpecs specs;
+		specs.channels = (Channels)channels;
+		specs.format = (SampleFormat)format;
+		specs.rate = (SampleRate)rate;
+
+		self->device = nullptr;
+
+		try
+		{
+			if(!device)
+			{
+				auto dev = DeviceManager::getDevice();
+				if(!dev)
+				{
+					DeviceManager::openDefaultDevice();
+					dev = DeviceManager::getDevice();
+				}
+				self->device = new std::shared_ptr<IDevice>(dev);
+			}
+			else
+			{
+				std::shared_ptr<IDeviceFactory> factory;
+				if(!*device)
+					factory = DeviceManager::getDefaultDeviceFactory();
+				else
+					factory = DeviceManager::getDeviceFactory(device);
+
+				if(factory)
+				{
+					factory->setName(name);
+					factory->setSpecs(specs);
+					factory->setBufferSize(buffersize);
+					self->device = new std::shared_ptr<IDevice>(factory->openDevice());
+				}
+			}
+		}
+		catch(Exception& e)
+		{
+			Py_DECREF(self);
+			PyErr_SetString(AUDError, e.what());
+			return nullptr;
+		}
+
+		if(!self->device)
+		{
+			Py_DECREF(self);
+			PyErr_SetString(AUDError, "Unsupported device type!");
+			return nullptr;
+		}
+	}
+
+	return (PyObject *)self;
+}
+
+PyDoc_STRVAR(M_aud_Device_lock_doc,
+			 ".. method:: lock()\n\n"
+			 "   Locks the device so that it's guaranteed, that no samples are\n"
+			 "   read from the streams until :meth:`unlock` is called.\n"
+			 "   This is useful if you want to do start/stop/pause/resume some\n"
+			 "   sounds at the same time.\n\n"
+			 "   .. note::\n\n"
+			 "      The device has to be unlocked as often as locked to be\n"
+			 "      able to continue playback.\n\n"
+			 "   .. warning::\n\n"
+			 "      Make sure the time between locking and unlocking is\n"
+			 "      as short as possible to avoid clicks.");
+
+static PyObject *
+Device_lock(Device* self)
+{
+	try
+	{
+		(*reinterpret_cast<std::shared_ptr<IDevice>*>(self->device))->lock();
+		Py_RETURN_NONE;
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+PyDoc_STRVAR(M_aud_Device_play_doc,
+			 ".. method:: play(sound, keep=False)\n\n"
+			 "   Plays a sound.\n\n"
+			 "   :arg sound: The sound to play.\n"
+			 "   :type sound: :class:`Sound`\n"
+			 "   :arg keep: See :attr:`Handle.keep`.\n"
+			 "   :type keep: bool\n"
+			 "   :return: The playback handle with which playback can be\n"
+			 "      controlled with.\n"
+			 "   :rtype: :class:`Handle`");
+
+static PyObject *
+Device_play(Device* self, PyObject* args, PyObject* kwds)
+{
+	PyObject* object;
+	PyObject* keepo = nullptr;
+
+	bool keep = false;
+
+	static const char* kwlist[] = {"sound", "keep", nullptr};
+
+	if(!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:play", const_cast<char**>(kwlist), &object, &keepo))
+		return nullptr;
+
+	Sound* sound = checkSound(object);
+
+	if(!sound)
+		return nullptr;
+
+	if(keepo != nullptr)
+	{
+		if(!PyBool_Check(keepo))
+		{
+			PyErr_SetString(PyExc_TypeError, "keep is not a boolean!");
+			return nullptr;
+		}
+
+		keep = keepo == Py_True;
+	}
+
+	Handle* handle;
+
+	handle = (Handle*)Handle_empty();
+	if(handle != nullptr)
+	{
+		try
+		{
+			handle->handle = new std::shared_ptr<IHandle>((*reinterpret_cast<std::shared_ptr<IDevice>*>(self->device))->play(*reinterpret_cast<std::shared_ptr<ISound>*>(sound->sound), keep));
+		}
+		catch(Exception& e)
+		{
+			Py_DECREF(handle);
+			PyErr_SetString(AUDError, e.what());
+			return nullptr;
+		}
+	}
+
+	return (PyObject *)handle;
+}
+
+PyDoc_STRVAR(M_aud_Device_stopAll_doc,
+			 ".. method:: stopAll()\n\n"
+			 "   Stops all playing and paused sounds.");
+
+static PyObject *
+Device_stopAll(Device* self)
+{
+	try
+	{
+		(*reinterpret_cast<std::shared_ptr<IDevice>*>(self->device))->stopAll();
+		Py_RETURN_NONE;
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+PyDoc_STRVAR(M_aud_Device_unlock_doc,
+			 ".. method:: unlock()\n\n"
+			 "   Unlocks the device after a lock call, see :meth:`lock` for\n"
+			 "   details.");
+
+static PyObject *
+Device_unlock(Device* self)
+{
+	try
+	{
+		(*reinterpret_cast<std::shared_ptr<IDevice>*>(self->device))->unlock();
+		Py_RETURN_NONE;
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+static PyMethodDef Device_methods[] = {
+	{"lock", (PyCFunction)Device_lock, METH_NOARGS,
+	 M_aud_Device_lock_doc
+	},
+	{"play", (PyCFunction)Device_play, METH_VARARGS | METH_KEYWORDS,
+	 M_aud_Device_play_doc
+	},
+	{"stopAll", (PyCFunction)Device_stopAll, METH_NOARGS,
+	 M_aud_Device_stopAll_doc
+	},
+	{"unlock", (PyCFunction)Device_unlock, METH_NOARGS,
+	 M_aud_Device_unlock_doc
+	},
+	{nullptr}  /* Sentinel */
+};
+
+PyDoc_STRVAR(M_aud_Device_channels_doc,
+			 "The channel count of the device.");
+
+static PyObject *
+Device_get_channels(Device* self, void* nothing)
+{
+	try
+	{
+		DeviceSpecs specs = (*reinterpret_cast<std::shared_ptr<IDevice>*>(self->device))->getSpecs();
+		return Py_BuildValue("i", specs.channels);
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+PyDoc_STRVAR(M_aud_Device_distance_model_doc,
+			 "The distance model of the device.\n\n"
+			 ".. seealso:: `OpenAL Documentation <https://www.openal.org/documentation/>`__");
+
+static PyObject *
+Device_get_distance_model(Device* self, void* nothing)
+{
+	try
+	{
+		I3DDevice* device = dynamic_cast<I3DDevice*>(reinterpret_cast<std::shared_ptr<IDevice>*>(self->device)->get());
+		if(device)
+		{
+			return Py_BuildValue("i", int(device->getDistanceModel()));
+		}
+		else
+		{
+			PyErr_SetString(AUDError, device_not_3d_error);
+			return nullptr;
+		}
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+static int
+Device_set_distance_model(Device* self, PyObject* args, void* nothing)
+{
+	int model;
+
+	if(!PyArg_Parse(args, "i:distance_model", &model))
+		return -1;
+
+	try
+	{
+		I3DDevice* device = dynamic_cast<I3DDevice*>(reinterpret_cast<std::shared_ptr<IDevice>*>(self->device)->get());
+		if(device)
+		{
+			device->setDistanceModel(DistanceModel(model));
+			return 0;
+		}
+		else
+			PyErr_SetString(AUDError, device_not_3d_error);
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+	}
+
+	return -1;
+}
+
+PyDoc_STRVAR(M_aud_Device_doppler_factor_doc,
+			 "The doppler factor of the device.\n"
+			 "This factor is a scaling factor for the velocity vectors in "
+			 "doppler calculation. So a value bigger than 1 will exaggerate "
+			 "the effect as it raises the velocity.");
+
+static PyObject *
+Device_get_doppler_factor(Device* self, void* nothing)
+{
+	try
+	{
+		I3DDevice* device = dynamic_cast<I3DDevice*>(reinterpret_cast<std::shared_ptr<IDevice>*>(self->device)->get());
+		if(device)
+		{
+			return Py_BuildValue("f", device->getDopplerFactor());
+		}
+		else
+		{
+			PyErr_SetString(AUDError, device_not_3d_error);
+			return nullptr;
+		}
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+static int
+Device_set_doppler_factor(Device* self, PyObject* args, void* nothing)
+{
+	float factor;
+
+	if(!PyArg_Parse(args, "f:doppler_factor", &factor))
+		return -1;
+
+	try
+	{
+		I3DDevice* device = dynamic_cast<I3DDevice*>(reinterpret_cast<std::shared_ptr<IDevice>*>(self->device)->get());
+		if(device)
+		{
+			device->setDopplerFactor(factor);
+			return 0;
+		}
+		else
+			PyErr_SetString(AUDError, device_not_3d_error);
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+	}
+
+	return -1;
+}
+
+PyDoc_STRVAR(M_aud_Device_format_doc,
+			 "The native sample format of the device.");
+
+static PyObject *
+Device_get_format(Device* self, void* nothing)
+{
+	try
+	{
+		DeviceSpecs specs = (*reinterpret_cast<std::shared_ptr<IDevice>*>(self->device))->getSpecs();
+		return Py_BuildValue("i", specs.format);
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+PyDoc_STRVAR(M_aud_Device_listener_location_doc,
+			 "The listeners's location in 3D space, a 3D tuple of floats.");
+
+static PyObject *
+Device_get_listener_location(Device* self, void* nothing)
+{
+	try
+	{
+		I3DDevice* device = dynamic_cast<I3DDevice*>(reinterpret_cast<std::shared_ptr<IDevice>*>(self->device)->get());
+		if(device)
+		{
+			Vector3 v = device->getListenerLocation();
+			return Py_BuildValue("(fff)", v.x(), v.y(), v.z());
+		}
+		else
+		{
+			PyErr_SetString(AUDError, device_not_3d_error);
+		}
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+	}
+
+	return nullptr;
+}
+
+static int
+Device_set_listener_location(Device* self, PyObject* args, void* nothing)
+{
+	float x, y, z;
+
+	if(!PyArg_Parse(args, "(fff):listener_location", &x, &y, &z))
+		return -1;
+
+	try
+	{
+		I3DDevice* device = dynamic_cast<I3DDevice*>(reinterpret_cast<std::shared_ptr<IDevice>*>(self->device)->get());
+		if(device)
+		{
+			Vector3 location(x, y, z);
+			device->setListenerLocation(location);
+			return 0;
+		}
+		else
+			PyErr_SetString(AUDError, device_not_3d_error);
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+	}
+
+	return -1;
+}
+
+PyDoc_STRVAR(M_aud_Device_listener_orientation_doc,
+			 "The listener's orientation in 3D space as quaternion, a 4 float tuple.");
+
+static PyObject *
+Device_get_listener_orientation(Device* self, void* nothing)
+{
+	try
+	{
+		I3DDevice* device = dynamic_cast<I3DDevice*>(reinterpret_cast<std::shared_ptr<IDevice>*>(self->device)->get());
+		if(device)
+		{
+			Quaternion o = device->getListenerOrientation();
+			return Py_BuildValue("(ffff)", o.w(), o.x(), o.y(), o.z());
+		}
+		else
+		{
+			PyErr_SetString(AUDError, device_not_3d_error);
+		}
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+	}
+
+	return nullptr;
+}
+
+static int
+Device_set_listener_orientation(Device* self, PyObject* args, void* nothing)
+{
+	float w, x, y, z;
+
+	if(!PyArg_Parse(args, "(ffff):listener_orientation", &w, &x, &y, &z))
+		return -1;
+
+	try
+	{
+		I3DDevice* device = dynamic_cast<I3DDevice*>(reinterpret_cast<std::shared_ptr<IDevice>*>(self->device)->get());
+		if(device)
+		{
+			Quaternion orientation(w, x, y, z);
+			device->setListenerOrientation(orientation);
+			return 0;
+		}
+		else
+			PyErr_SetString(AUDError, device_not_3d_error);
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+	}
+
+	return -1;
+}
+
+PyDoc_STRVAR(M_aud_Device_listener_velocity_doc,
+			 "The listener's velocity in 3D space, a 3D tuple of floats.");
+
+static PyObject *
+Device_get_listener_velocity(Device* self, void* nothing)
+{
+	try
+	{
+		I3DDevice* device = dynamic_cast<I3DDevice*>(reinterpret_cast<std::shared_ptr<IDevice>*>(self->device)->get());
+		if(device)
+		{
+			Vector3 v = device->getListenerVelocity();
+			return Py_BuildValue("(fff)", v.x(), v.y(), v.z());
+		}
+		else
+		{
+			PyErr_SetString(AUDError, device_not_3d_error);
+		}
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+	}
+
+	return nullptr;
+}
+
+static int
+Device_set_listener_velocity(Device* self, PyObject* args, void* nothing)
+{
+	float x, y, z;
+
+	if(!PyArg_Parse(args, "(fff):listener_velocity", &x, &y, &z))
+		return -1;
+
+	try
+	{
+		I3DDevice* device = dynamic_cast<I3DDevice*>(reinterpret_cast<std::shared_ptr<IDevice>*>(self->device)->get());
+		if(device)
+		{
+			Vector3 velocity(x, y, z);
+			device->setListenerVelocity(velocity);
+			return 0;
+		}
+		else
+			PyErr_SetString(AUDError, device_not_3d_error);
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+	}
+
+	return -1;
+}
+
+PyDoc_STRVAR(M_aud_Device_rate_doc,
+			 "The sampling rate of the device in Hz.");
+
+static PyObject *
+Device_get_rate(Device* self, void* nothing)
+{
+	try
+	{
+		DeviceSpecs specs = (*reinterpret_cast<std::shared_ptr<IDevice>*>(self->device))->getSpecs();
+		return Py_BuildValue("d", specs.rate);
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+PyDoc_STRVAR(M_aud_Device_speed_of_sound_doc,
+			 "The speed of sound of the device.\n"
+			 "The speed of sound in air is typically 343.3 m/s.");
+
+static PyObject *
+Device_get_speed_of_sound(Device* self, void* nothing)
+{
+	try
+	{
+		I3DDevice* device = dynamic_cast<I3DDevice*>(reinterpret_cast<std::shared_ptr<IDevice>*>(self->device)->get());
+		if(device)
+		{
+			return Py_BuildValue("f", device->getSpeedOfSound());
+		}
+		else
+		{
+			PyErr_SetString(AUDError, device_not_3d_error);
+			return nullptr;
+		}
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+static int
+Device_set_speed_of_sound(Device* self, PyObject* args, void* nothing)
+{
+	float speed;
+
+	if(!PyArg_Parse(args, "f:speed_of_sound", &speed))
+		return -1;
+
+	try
+	{
+		I3DDevice* device = dynamic_cast<I3DDevice*>(reinterpret_cast<std::shared_ptr<IDevice>*>(self->device)->get());
+		if(device)
+		{
+			device->setSpeedOfSound(speed);
+			return 0;
+		}
+		else
+			PyErr_SetString(AUDError, device_not_3d_error);
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+	}
+
+	return -1;
+}
+
+PyDoc_STRVAR(M_aud_Device_volume_doc,
+			 "The overall volume of the device.");
+
+static PyObject *
+Device_get_volume(Device* self, void* nothing)
+{
+	try
+	{
+		return Py_BuildValue("f", (*reinterpret_cast<std::shared_ptr<IDevice>*>(self->device))->getVolume());
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+static int
+Device_set_volume(Device* self, PyObject* args, void* nothing)
+{
+	float volume;
+
+	if(!PyArg_Parse(args, "f:volume", &volume))
+		return -1;
+
+	try
+	{
+		(*reinterpret_cast<std::shared_ptr<IDevice>*>(self->device))->setVolume(volume);
+		return 0;
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return -1;
+	}
+}
+
+static PyGetSetDef Device_properties[] = {
+	{(char*)"channels", (getter)Device_get_channels, nullptr,
+	 M_aud_Device_channels_doc, nullptr },
+	{(char*)"distance_model", (getter)Device_get_distance_model, (setter)Device_set_distance_model,
+	 M_aud_Device_distance_model_doc, nullptr },
+	{(char*)"doppler_factor", (getter)Device_get_doppler_factor, (setter)Device_set_doppler_factor,
+	 M_aud_Device_doppler_factor_doc, nullptr },
+	{(char*)"format", (getter)Device_get_format, nullptr,
+	 M_aud_Device_format_doc, nullptr },
+	{(char*)"listener_location", (getter)Device_get_listener_location, (setter)Device_set_listener_location,
+	 M_aud_Device_listener_location_doc, nullptr },
+	{(char*)"listener_orientation", (getter)Device_get_listener_orientation, (setter)Device_set_listener_orientation,
+	 M_aud_Device_listener_orientation_doc, nullptr },
+	{(char*)"listener_velocity", (getter)Device_get_listener_velocity, (setter)Device_set_listener_velocity,
+	 M_aud_Device_listener_velocity_doc, nullptr },
+	{(char*)"rate", (getter)Device_get_rate, nullptr,
+	 M_aud_Device_rate_doc, nullptr },
+	{(char*)"speed_of_sound", (getter)Device_get_speed_of_sound, (setter)Device_set_speed_of_sound,
+	 M_aud_Device_speed_of_sound_doc, nullptr },
+	{(char*)"volume", (getter)Device_get_volume, (setter)Device_set_volume,
+	 M_aud_Device_volume_doc, nullptr },
+	{nullptr}  /* Sentinel */
+};
+
+PyDoc_STRVAR(M_aud_Device_doc,
+			 ".. class:: Device(type='', rate=48000.0, channels=2, format=36, buffer_size=1024, name='')\n\n"
+			 "   Device objects represent an audio output backend like OpenAL or "
+			 "SDL, but might also represent a file output or RAM buffer "
+			 "output.\n\n"
+			 "   :arg type: The device type. An empty string means the default device.\n"
+			 "   :type type: string\n"
+			 "   :arg rate: The sample rate in Hz.\n"
+			 "   :type rate: double\n"
+			 "   :arg channels: The number of channels.\n"
+			 "   :type channels: int\n"
+			 "   :arg format: The sample format.\n"
+			 "   :type format: int\n"
+			 "   :arg buffer_size: The size of the audio buffer in samples.\n"
+			 "   :type buffer_size: int\n"
+			 "   :arg name: The name of the device.\n"
+			 "   :type name: string\n");
+
+static PyTypeObject DeviceType = {
+	PyVarObject_HEAD_INIT(nullptr, 0)
+	"aud.Device",              /* tp_name */
+	sizeof(Device),            /* tp_basicsize */
+	0,                         /* tp_itemsize */
+	(destructor)Device_dealloc,/* tp_dealloc */
+	0,                         /* tp_print */
+	0,                         /* tp_getattr */
+	0,                         /* tp_setattr */
+	0,                         /* tp_reserved */
+	0,                         /* tp_repr */
+	0,                         /* tp_as_number */
+	0,                         /* tp_as_sequence */
+	0,                         /* tp_as_mapping */
+	0,                         /* tp_hash  */
+	0,                         /* tp_call */
+	0,                         /* tp_str */
+	0,                         /* tp_getattro */
+	0,                         /* tp_setattro */
+	0,                         /* tp_as_buffer */
+	Py_TPFLAGS_DEFAULT,        /* tp_flags */
+	M_aud_Device_doc,          /* tp_doc */
+	0,		                   /* tp_traverse */
+	0,		                   /* tp_clear */
+	0,		                   /* tp_richcompare */
+	0,		                   /* tp_weaklistoffset */
+	0,		                   /* tp_iter */
+	0,		                   /* tp_iternext */
+	Device_methods,            /* tp_methods */
+	0,                         /* tp_members */
+	Device_properties,         /* tp_getset */
+	0,                         /* tp_base */
+	0,                         /* tp_dict */
+	0,                         /* tp_descr_get */
+	0,                         /* tp_descr_set */
+	0,                         /* tp_dictoffset */
+	0,                         /* tp_init */
+	0,                         /* tp_alloc */
+	Device_new,                /* tp_new */
+};
+
+AUD_API PyObject* Device_empty()
+{
+	return DeviceType.tp_alloc(&DeviceType, 0);
+}
+
+
+AUD_API Device* checkDevice(PyObject* device)
+{
+	if(!PyObject_TypeCheck(device, &DeviceType))
+	{
+		PyErr_SetString(PyExc_TypeError, "Object is not of type Device!");
+		return nullptr;
+	}
+
+	return (Device*)device;
+}
+
+
+bool initializeDevice()
+{
+	return PyType_Ready(&DeviceType) >= 0;
+}
+
+
+void addDeviceToModule(PyObject* module)
+{
+	Py_INCREF(&DeviceType);
+	PyModule_AddObject(module, "Device", (PyObject *)&DeviceType);
+}

blender-5.2.0/extern/audaspace/bindings/python/PyDevice.h

@@ -0,0 +1,33 @@
+/*******************************************************************************
+ * 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.
+ ******************************************************************************/
+
+#pragma once
+
+#include <Python.h>
+#include "Audaspace.h"
+
+typedef void Reference_IDevice;
+
+typedef struct {
+	PyObject_HEAD
+	Reference_IDevice* device;
+} Device;
+
+extern AUD_API PyObject* Device_empty();
+extern AUD_API Device* checkDevice(PyObject* device);
+
+bool initializeDevice();
+void addDeviceToModule(PyObject* module);

blender-5.2.0/extern/audaspace/bindings/python/PyDynamicMusic.cpp

@@ -0,0 +1,470 @@
+/*******************************************************************************
+* Copyright 2015-2016 Juan Francisco Crespo Galán
+*
+* 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 "PyDynamicMusic.h"
+#include "PySound.h"
+#include "PyHandle.h"
+#include "PyDevice.h"
+
+#include "Exception.h"
+#include "fx/DynamicMusic.h"
+
+extern PyObject* AUDError;
+
+static PyObject *
+DynamicMusic_new(PyTypeObject* type, PyObject* args, PyObject* kwds)
+{
+	DynamicMusicP* self = (DynamicMusicP*)type->tp_alloc(type, 0);
+
+	if(self != nullptr)
+	{
+		PyObject* object;
+		if(!PyArg_ParseTuple(args, "O:device", &object))
+			return nullptr;
+		Device* device = checkDevice(object);
+
+		try
+		{
+			self->dynamicMusic = new std::shared_ptr<aud::DynamicMusic>(new aud::DynamicMusic(*reinterpret_cast<std::shared_ptr<aud::IDevice>*>(device->device)));
+		}
+		catch(aud::Exception& e)
+		{
+			Py_DECREF(self);
+			PyErr_SetString(AUDError, e.what());
+			return nullptr;
+		}
+	}
+
+	return (PyObject *)self;
+}
+
+static void
+DynamicMusic_dealloc(DynamicMusicP* self)
+{
+	if(self->dynamicMusic)
+		delete reinterpret_cast<std::shared_ptr<aud::DynamicMusic>*>(self->dynamicMusic);
+	Py_TYPE(self)->tp_free((PyObject *)self);
+}
+
+PyDoc_STRVAR(M_aud_DynamicMusic_addScene_doc,
+	".. method:: addScene(scene)\n\n"
+	"   Adds a new scene.\n\n"
+	"   :arg scene: The scene sound.\n"
+	"   :type scene: :class:`Sound`\n"
+	"   :return: The new scene id.\n"
+	"   :rtype: int");
+
+static PyObject *
+DynamicMusic_addScene(DynamicMusicP* self, PyObject* args)
+{
+	PyObject* object;
+	if(!PyArg_Parse(args, "O:sound", &object))
+		return nullptr;
+
+	Sound* sound = checkSound(object);
+	if(!sound)
+		return nullptr;
+
+	try
+	{
+		return Py_BuildValue("i", (*reinterpret_cast<std::shared_ptr<aud::DynamicMusic>*>(self->dynamicMusic))->addScene(*reinterpret_cast<std::shared_ptr<aud::ISound>*>(sound->sound)));
+	}
+	catch(aud::Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+PyDoc_STRVAR(M_aud_DynamicMusic_addTransition_doc,
+	".. method:: addTransition(ini, end, transition)\n\n"
+	"   Adds a new scene.\n\n"
+	"   :arg ini: the initial scene foor the transition.\n"
+	"   :type ini: int\n"
+	"   :arg end: The final scene for the transition.\n"
+	"   :type end: int\n"
+	"   :arg transition: The transition sound.\n"
+	"   :type transition: :class:`Sound`\n"
+	"   :return: false if the ini or end scenes don't exist, true otherwise.\n"
+	"   :rtype: bool");
+
+static PyObject *
+DynamicMusic_addTransition(DynamicMusicP* self, PyObject* args)
+{
+	PyObject* object;
+	int ini, end;
+	if(!PyArg_ParseTuple(args, "iiO:sound", &ini, &end, &object))
+		return nullptr;
+	Sound* sound = checkSound(object);
+	if(!sound)
+		return nullptr;
+
+	try
+	{
+		(*reinterpret_cast<std::shared_ptr<aud::DynamicMusic>*>(self->dynamicMusic))->addTransition(ini, end, *reinterpret_cast<std::shared_ptr<aud::ISound>*>(sound->sound));
+		Py_RETURN_NONE;
+	}
+	catch(aud::Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+PyDoc_STRVAR(M_aud_DynamicMusic_resume_doc,
+	".. method:: resume()\n\n"
+	"   Resumes playback of the scene.\n\n"
+	"   :return: Whether the action succeeded.\n"
+	"   :rtype: bool");
+
+static PyObject *
+DynamicMusic_resume(DynamicMusicP* self)
+{
+	try
+	{
+		return PyBool_FromLong((long)(*reinterpret_cast<std::shared_ptr<aud::DynamicMusic>*>(self->dynamicMusic))->resume());
+	}
+	catch(aud::Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+PyDoc_STRVAR(M_aud_DynamicMusic_pause_doc,
+	".. method:: pause()\n\n"
+	"   Pauses playback of the scene.\n\n"
+	"   :return: Whether the action succeeded.\n"
+	"   :rtype: bool");
+
+static PyObject *
+DynamicMusic_pause(DynamicMusicP* self)
+{
+	try
+	{
+		return PyBool_FromLong((long)(*reinterpret_cast<std::shared_ptr<aud::DynamicMusic>*>(self->dynamicMusic))->pause());
+	}
+	catch(aud::Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+PyDoc_STRVAR(M_aud_DynamicMusic_stop_doc,
+	".. method:: stop()\n\n"
+	"   Stops playback of the scene.\n\n"
+	"   :return: Whether the action succeeded.\n"
+	"   :rtype: bool\n\n");
+
+static PyObject *
+DynamicMusic_stop(DynamicMusicP* self)
+{
+	try
+	{
+		return PyBool_FromLong((long)(*reinterpret_cast<std::shared_ptr<aud::DynamicMusic>*>(self->dynamicMusic))->stop());
+	}
+	catch(aud::Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+static PyMethodDef DynamicMusic_methods[] = {
+	{ "addScene", (PyCFunction)DynamicMusic_addScene, METH_O,
+	M_aud_DynamicMusic_addScene_doc
+	},
+	{ "addTransition", (PyCFunction)DynamicMusic_addTransition, METH_VARARGS,
+	M_aud_DynamicMusic_addTransition_doc
+	},
+	{ "resume", (PyCFunction)DynamicMusic_resume, METH_NOARGS,
+	M_aud_DynamicMusic_resume_doc
+	},
+	{ "pause", (PyCFunction)DynamicMusic_pause, METH_NOARGS,
+	M_aud_DynamicMusic_pause_doc
+	},
+	{ "stop", (PyCFunction)DynamicMusic_stop, METH_NOARGS,
+	M_aud_DynamicMusic_stop_doc
+	},
+	{ nullptr }  /* Sentinel */
+};
+
+/////////////////////////////////////////////////////
+
+PyDoc_STRVAR(M_aud_DynamicMusic_status_doc,
+	"Whether the scene is playing, paused or stopped (=invalid).");
+
+static PyObject *
+DynamicMusic_get_status(DynamicMusicP* self, void* nothing)
+{
+	try
+	{
+		return PyBool_FromLong((long)(*reinterpret_cast<std::shared_ptr<aud::DynamicMusic>*>(self->dynamicMusic))->getStatus());
+	}
+	catch(aud::Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+PyDoc_STRVAR(M_aud_DynamicMusic_position_doc,
+	"The playback position of the scene in seconds.");
+
+static int
+DynamicMusic_set_position(DynamicMusicP* self, PyObject* args, void* nothing)
+{
+	double position;
+
+	if(!PyArg_Parse(args, "d:position", &position))
+		return -1;
+
+	try
+	{
+		if((*reinterpret_cast<std::shared_ptr<aud::DynamicMusic>*>(self->dynamicMusic))->seek(position))
+			return 0;
+		PyErr_SetString(AUDError, "Couldn't seek the sound!");
+	}
+	catch(aud::Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+	}
+
+	return -1;
+}
+
+static PyObject *
+DynamicMusic_get_position(DynamicMusicP* self, void* nothing)
+{
+	try
+	{
+		return Py_BuildValue("d", (*reinterpret_cast<std::shared_ptr<aud::DynamicMusic>*>(self->dynamicMusic))->getPosition());
+	}
+	catch(aud::Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+PyDoc_STRVAR(M_aud_DynamicMusic_fadeTime_doc,
+	"The length in seconds of the crossfade transition");
+
+static int
+DynamicMusic_set_fadeTime(DynamicMusicP* self, PyObject* args, void* nothing)
+{
+	float fadeTime;
+
+	if(!PyArg_Parse(args, "f:fadeTime", &fadeTime))
+		return -1;
+
+	try
+	{
+		(*reinterpret_cast<std::shared_ptr<aud::DynamicMusic>*>(self->dynamicMusic))->setFadeTime(fadeTime);
+		return 0;
+	}
+	catch(aud::Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+	}
+
+	return -1;
+}
+
+static PyObject *
+DynamicMusic_get_fadeTime(DynamicMusicP* self, void* nothing)
+{
+	try
+	{
+		return Py_BuildValue("f", (*reinterpret_cast<std::shared_ptr<aud::DynamicMusic>*>(self->dynamicMusic))->getFadeTime());
+	}
+	catch(aud::Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+PyDoc_STRVAR(M_aud_DynamicMusic_scene_doc,
+	"The current scene");
+
+static int
+DynamicMusic_set_scene(DynamicMusicP* self, PyObject* args, void* nothing)
+{
+	int scene;
+
+	if(!PyArg_Parse(args, "i:scene", &scene))
+		return -1;
+
+	try
+	{
+		if((*reinterpret_cast<std::shared_ptr<aud::DynamicMusic>*>(self->dynamicMusic))->changeScene(scene))
+			return 0;
+		PyErr_SetString(AUDError, "Couldn't change the scene!");
+	}
+	catch(aud::Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+	}
+
+	return -1;
+}
+
+static PyObject *
+DynamicMusic_get_scene(DynamicMusicP* self, void* nothing)
+{
+	try
+	{
+		return Py_BuildValue("i", (*reinterpret_cast<std::shared_ptr<aud::DynamicMusic>*>(self->dynamicMusic))->getScene());
+	}
+	catch(aud::Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+PyDoc_STRVAR(M_aud_DynamicMusic_volume_doc,
+	"The volume of the scene.");
+
+static int
+DynamicMusic_set_volume(DynamicMusicP* self, PyObject* args, void* nothing)
+{
+	float volume;
+
+	if(!PyArg_Parse(args, "f:volume", &volume))
+		return -1;
+
+	try
+	{
+		if((*reinterpret_cast<std::shared_ptr<aud::DynamicMusic>*>(self->dynamicMusic))->setVolume(volume))
+			return 0;
+		PyErr_SetString(AUDError, "Couldn't change the volume!");
+	}
+	catch(aud::Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+	}
+
+	return -1;
+}
+
+static PyObject *
+DynamicMusic_get_volume(DynamicMusicP* self, void* nothing)
+{
+	try
+	{
+		return Py_BuildValue("f", (*reinterpret_cast<std::shared_ptr<aud::DynamicMusic>*>(self->dynamicMusic))->getVolume());
+	}
+	catch(aud::Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+static PyGetSetDef DynamicMusic_properties[] = {
+	{ (char*)"status", (getter)DynamicMusic_get_status, nullptr,
+	M_aud_DynamicMusic_status_doc, nullptr },
+	{ (char*)"position", (getter)DynamicMusic_get_position, (setter)DynamicMusic_set_position,
+	M_aud_DynamicMusic_position_doc, nullptr },
+	{ (char*)"fadeTime", (getter)DynamicMusic_get_fadeTime, (setter)DynamicMusic_set_fadeTime,
+	M_aud_DynamicMusic_fadeTime_doc, nullptr },
+	{ (char*)"scene", (getter)DynamicMusic_get_scene, (setter)DynamicMusic_set_scene,
+	M_aud_DynamicMusic_scene_doc, nullptr },
+	{ (char*)"volume", (getter)DynamicMusic_get_volume, (setter)DynamicMusic_set_volume,
+	M_aud_DynamicMusic_volume_doc, nullptr },
+	{ nullptr }  /* Sentinel */
+};
+
+PyDoc_STRVAR(M_aud_DynamicMusic_doc,
+	".. class:: DynamicMusic(device, /)\n\n"
+	"   The DynamicMusic object allows to play music depending on a current scene, scene changes are managed by the class, with the possibility of custom transitions.\n"
+	"   The default transition is a crossfade effect, and the default scene is silent and has id 0.\n\n"
+	"   :arg device: The device that will be used to play sounds.\n"
+	"   :type device: :class:`Device`\n");
+
+PyTypeObject DynamicMusicType = {
+	PyVarObject_HEAD_INIT(nullptr, 0)
+	"aud.DynamicMusic",						/* tp_name */
+	sizeof(DynamicMusicP),					/* tp_basicsize */
+	0,										/* tp_itemsize */
+	(destructor)DynamicMusic_dealloc,		/* tp_dealloc */
+	0,										/* tp_print */
+	0,										/* tp_getattr */
+	0,										/* tp_setattr */
+	0,										/* tp_reserved */
+	0,										/* tp_repr */
+	0,										/* tp_as_number */
+	0,										/* tp_as_sequence */
+	0,										/* tp_as_mapping */
+	0,										/* tp_hash  */
+	0,										/* tp_call */
+	0,										/* tp_str */
+	0,										/* tp_getattro */
+	0,										/* tp_setattro */
+	0,										/* tp_as_buffer */
+	Py_TPFLAGS_DEFAULT,						/* tp_flags */
+	M_aud_DynamicMusic_doc,					/* tp_doc */
+	0,										/* tp_traverse */
+	0,										/* tp_clear */
+	0,										/* tp_richcompare */
+	0,										/* tp_weaklistoffset */
+	0,										/* tp_iter */
+	0,										/* tp_iternext */
+	DynamicMusic_methods,					/* tp_methods */
+	0,										/* tp_members */
+	DynamicMusic_properties,				/* tp_getset */
+	0,										/* tp_base */
+	0,										/* tp_dict */
+	0,										/* tp_descr_get */
+	0,										/* tp_descr_set */
+	0,										/* tp_dictoffset */
+	0,										/* tp_init */
+	0,										/* tp_alloc */
+	DynamicMusic_new,						/* tp_new */
+};
+
+AUD_API PyObject* DynamicMusic_empty()
+{
+	return DynamicMusicType.tp_alloc(&DynamicMusicType, 0);
+}
+
+
+AUD_API DynamicMusicP* checkDynamicMusic(PyObject* dynamicMusic)
+{
+	if(!PyObject_TypeCheck(dynamicMusic, &DynamicMusicType))
+	{
+		PyErr_SetString(PyExc_TypeError, "Object is not of type DynamicMusic!");
+		return nullptr;
+	}
+
+	return (DynamicMusicP*)dynamicMusic;
+}
+
+
+bool initializeDynamicMusic()
+{
+	return PyType_Ready(&DynamicMusicType) >= 0;
+}
+
+
+void addDynamicMusicToModule(PyObject* module)
+{
+	Py_INCREF(&DynamicMusicType);
+	PyModule_AddObject(module, "DynamicMusic", (PyObject *)&DynamicMusicType);
+}

blender-5.2.0/extern/audaspace/bindings/python/PyDynamicMusic.h

@@ -0,0 +1,33 @@
+/*******************************************************************************
+* Copyright 2015-2016 Juan Francisco Crespo Galán
+*
+* 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.
+******************************************************************************/
+
+#pragma once
+
+#include <Python.h>
+#include "Audaspace.h"
+
+typedef void Reference_DynamicMusic;
+
+typedef struct {
+	PyObject_HEAD
+		Reference_DynamicMusic* dynamicMusic;
+} DynamicMusicP;
+
+extern AUD_API PyObject* DynamicMusic_empty();
+extern AUD_API DynamicMusicP* checkDynamicMusic(PyObject* dynamicMusic);
+
+bool initializeDynamicMusic();
+void addDynamicMusicToModule(PyObject* module);

blender-5.2.0/extern/audaspace/bindings/python/PyHRTF.cpp

@@ -0,0 +1,248 @@
+/*******************************************************************************
+* Copyright 2009-2015 Juan Francisco Crespo Galán
+*
+* 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 "PyHRTF.h"
+#include "PySound.h"
+
+#include "Exception.h"
+#include "fx/HRTF.h"
+#include "fx/HRTFLoader.h"
+
+extern PyObject* AUDError;
+
+static PyObject *
+HRTF_new(PyTypeObject* type, PyObject* args, PyObject* kwds)
+{
+	HRTFP* self = (HRTFP*)type->tp_alloc(type, 0);
+
+	if(self != nullptr)
+	{
+		try
+		{
+			self->hrtf = new std::shared_ptr<aud::HRTF>(new aud::HRTF());
+		}
+		catch(aud::Exception& e)
+		{
+			Py_DECREF(self);
+			PyErr_SetString(AUDError, e.what());
+			return nullptr;
+		}
+	}
+
+	return (PyObject *)self;
+}
+
+static void
+HRTF_dealloc(HRTFP* self)
+{
+	if(self->hrtf)
+		delete reinterpret_cast<std::shared_ptr<aud::HRTF>*>(self->hrtf);
+	Py_TYPE(self)->tp_free((PyObject *)self);
+}
+
+PyDoc_STRVAR(M_aud_HRTF_addImpulseResponse_doc,
+	".. method:: addImpulseResponseFromSound(sound, azimuth, elevation)\n\n"
+	"   Adds a new hrtf to the HRTF object\n\n"
+	"   :arg sound: The sound that contains the hrtf.\n"
+	"   :type sound: :class:`Sound`\n"
+	"   :arg azimuth: The azimuth angle of the hrtf.\n"
+	"   :type azimuth: float\n"
+	"   :arg elevation: The elevation angle of the hrtf.\n"
+	"   :type elevation: float\n"
+	"   :return: Whether the action succeeded.\n"
+	"   :rtype: bool");
+
+static PyObject *
+HRTF_addImpulseResponseFromSound(HRTFP* self, PyObject* args)
+{
+	PyObject* object;
+	float azimuth, elevation;
+
+	if(!PyArg_ParseTuple(args, "Off:hrtf", &object, &azimuth, &elevation))
+		return nullptr;
+
+	Sound* ir = checkSound(object);
+	if(!ir)
+		return nullptr;
+
+	try
+	{
+		return PyBool_FromLong((long)(*reinterpret_cast<std::shared_ptr<aud::HRTF>*>(self->hrtf))->addImpulseResponse(std::make_shared<aud::StreamBuffer>(*reinterpret_cast<std::shared_ptr<aud::ISound>*>(ir->sound)), azimuth, elevation));
+	}
+	catch(aud::Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+PyDoc_STRVAR(M_aud_HRTF_loadLeftHrtfSet_doc,
+	".. method:: loadLeftHrtfSet(extension, directory)\n\n"
+	"   Loads all HRTFs from a directory.\n\n"
+	"   :arg extension: The file extension of the hrtfs.\n"
+	"   :type extension: string\n"
+	"   :arg directory: The path to where the HRTF files are located.\n"
+	"   :type extension: string\n"
+	"   :return: The loaded :class:`HRTF` object.\n"
+	"   :rtype: :class:`HRTF`\n\n");
+
+static PyObject *
+HRTF_loadLeftHrtfSet(PyTypeObject* type, PyObject* args)
+{
+	const char* dir = nullptr;
+	const char* ext = nullptr;
+
+	if(!PyArg_ParseTuple(args, "ss:hrtf", &ext, &dir))
+		return nullptr;
+
+	HRTFP* self;
+	self = (HRTFP*)type->tp_alloc(type, 0);
+
+	try
+	{
+		self->hrtf = new std::shared_ptr<aud::HRTF>(aud::HRTFLoader::loadLeftHRTFs(ext, dir));
+	}
+	catch(aud::Exception& e)
+	{
+		Py_DECREF(self);
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+	return (PyObject *)self;
+}
+
+PyDoc_STRVAR(M_aud_HRTF_loadRightHrtfSet_doc,
+	".. method:: loadRightHrtfSet(extension, directory)\n\n"
+	"   Loads all HRTFs from a directory.\n\n"
+	"   :arg extension: The file extension of the hrtfs.\n"
+	"   :type extension: string\n"
+	"   :arg directory: The path to where the HRTF files are located.\n"
+	"   :type extension: string\n"
+	"   :return: The loaded :class:`HRTF` object.\n"
+	"   :rtype: :class:`HRTF`\n\n");
+
+static PyObject *
+HRTF_loadRightHrtfSet(PyTypeObject* type, PyObject* args)
+{
+	const char* dir = nullptr;
+	const char* ext = nullptr;
+
+	if(!PyArg_ParseTuple(args, "ss:hrtf", &ext, &dir))
+		return nullptr;
+
+	HRTFP* self;
+	self = (HRTFP*)type->tp_alloc(type, 0);
+
+	try
+	{
+		self->hrtf = new std::shared_ptr<aud::HRTF>(aud::HRTFLoader::loadRightHRTFs(ext, dir));
+	}
+	catch(aud::Exception& e)
+	{
+		Py_DECREF(self);
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+	return (PyObject *)self;
+}
+
+static PyMethodDef HRTF_methods[] = {
+	{ "addImpulseResponseFromSound", (PyCFunction)HRTF_addImpulseResponseFromSound, METH_VARARGS | METH_KEYWORDS,
+	M_aud_HRTF_addImpulseResponse_doc
+	},
+	{ "loadLeftHrtfSet", (PyCFunction)HRTF_loadLeftHrtfSet, METH_VARARGS | METH_CLASS,
+	M_aud_HRTF_loadLeftHrtfSet_doc
+	},
+	{ "loadRightHrtfSet", (PyCFunction)HRTF_loadRightHrtfSet, METH_VARARGS | METH_CLASS,
+	M_aud_HRTF_loadRightHrtfSet_doc
+	},
+	{ nullptr }  /* Sentinel */
+};
+
+PyDoc_STRVAR(M_aud_HRTF_doc,
+	".. class:: HRTF()\n\n"
+	"   An HRTF object represents a set of head related transfer functions as impulse responses. It's used for binaural sound.\n");
+
+PyTypeObject HRTFType = {
+	PyVarObject_HEAD_INIT(nullptr, 0)
+	"aud.HRTF",								/* tp_name */
+	sizeof(HRTFP),							/* tp_basicsize */
+	0,										/* tp_itemsize */
+	(destructor)HRTF_dealloc,				/* tp_dealloc */
+	0,										/* tp_print */
+	0,										/* tp_getattr */
+	0,										/* tp_setattr */
+	0,										/* tp_reserved */
+	0,										/* tp_repr */
+	0,										/* tp_as_number */
+	0,										/* tp_as_sequence */
+	0,										/* tp_as_mapping */
+	0,										/* tp_hash  */
+	0,										/* tp_call */
+	0,										/* tp_str */
+	0,										/* tp_getattro */
+	0,										/* tp_setattro */
+	0,										/* tp_as_buffer */
+	Py_TPFLAGS_DEFAULT,						/* tp_flags */
+	M_aud_HRTF_doc,							/* tp_doc */
+	0,										/* tp_traverse */
+	0,										/* tp_clear */
+	0,										/* tp_richcompare */
+	0,										/* tp_weaklistoffset */
+	0,										/* tp_iter */
+	0,										/* tp_iternext */
+	HRTF_methods,							/* tp_methods */
+	0,										/* tp_members */
+	0,										/* tp_getset */
+	0,										/* tp_base */
+	0,										/* tp_dict */
+	0,										/* tp_descr_get */
+	0,										/* tp_descr_set */
+	0,										/* tp_dictoffset */
+	0,										/* tp_init */
+	0,										/* tp_alloc */
+	HRTF_new,								/* tp_new */
+};
+
+AUD_API PyObject* HRTF_empty()
+{
+	return HRTFType.tp_alloc(&HRTFType, 0);
+}
+
+
+AUD_API HRTFP* checkHRTF(PyObject* hrtf)
+{
+	if(!PyObject_TypeCheck(hrtf, &HRTFType))
+	{
+		PyErr_SetString(PyExc_TypeError, "Object is not of type HRTF!");
+		return nullptr;
+	}
+
+	return (HRTFP*)hrtf;
+}
+
+
+bool initializeHRTF()
+{
+	return PyType_Ready(&HRTFType) >= 0;
+}
+
+
+void addHRTFToModule(PyObject* module)
+{
+	Py_INCREF(&HRTFType);
+	PyModule_AddObject(module, "HRTF", (PyObject *)&HRTFType);
+}

blender-5.2.0/extern/audaspace/bindings/python/PyHRTF.h

@@ -0,0 +1,33 @@
+/*******************************************************************************
+* Copyright 2009-2015 Juan Francisco Crespo Galán
+*
+* 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.
+******************************************************************************/
+
+#pragma once
+
+#include <Python.h>
+#include "Audaspace.h"
+
+typedef void Reference_HRTF;
+
+typedef struct {
+	PyObject_HEAD
+	Reference_HRTF* hrtf;
+} HRTFP;
+
+extern AUD_API PyObject* HRTF_empty();
+extern AUD_API HRTFP* checkHRTF(PyObject* hrtf);
+
+bool initializeHRTF();
+void addHRTFToModule(PyObject* module);

blender-5.2.0/extern/audaspace/bindings/python/PyHandle.h

@@ -0,0 +1,33 @@
+/*******************************************************************************
+ * 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.
+ ******************************************************************************/
+
+#pragma once
+
+#include <Python.h>
+#include "Audaspace.h"
+
+typedef void Reference_IHandle;
+
+typedef struct {
+	PyObject_HEAD
+	Reference_IHandle* handle;
+} Handle;
+
+extern AUD_API PyObject* Handle_empty();
+extern AUD_API Handle* checkHandle(PyObject* handle);
+
+bool initializeHandle();
+void addHandleToModule(PyObject* module);

blender-5.2.0/extern/audaspace/bindings/python/PyImpulseResponse.cpp

@@ -0,0 +1,140 @@
+/*******************************************************************************
+* Copyright 2009-2015 Juan Francisco Crespo Galán
+*
+* 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 "PyImpulseResponse.h"
+#include "PySound.h"
+
+#include "Exception.h"
+#include "fx/ImpulseResponse.h"
+#include "util/StreamBuffer.h"
+
+extern PyObject* AUDError;
+
+static PyObject *
+ImpulseResponse_new(PyTypeObject* type, PyObject* args, PyObject* kwds)
+{
+	ImpulseResponseP* self = (ImpulseResponseP*)type->tp_alloc(type, 0);
+
+	if(self != nullptr)
+	{
+		PyObject* object;
+		if(!PyArg_ParseTuple(args, "O:sound", &object))
+			return nullptr;
+		Sound* sound = checkSound(object);
+
+		try
+		{
+			self->impulseResponse = new std::shared_ptr<aud::ImpulseResponse>(new aud::ImpulseResponse(std::make_shared<aud::StreamBuffer>(*reinterpret_cast<std::shared_ptr<aud::ISound>*>(sound->sound))));
+		}
+		catch(aud::Exception& e)
+		{
+			Py_DECREF(self);
+			PyErr_SetString(AUDError, e.what());
+			return nullptr;
+		}
+	}
+
+	return (PyObject *)self;
+}
+
+static void
+ImpulseResponse_dealloc(ImpulseResponseP* self)
+{
+	if(self->impulseResponse)
+		delete reinterpret_cast<std::shared_ptr<aud::ImpulseResponse>*>(self->impulseResponse);
+	Py_TYPE(self)->tp_free((PyObject *)self);
+}
+
+static PyMethodDef ImpulseResponse_methods[] = {
+	{ nullptr }  /* Sentinel */
+};
+
+PyDoc_STRVAR(M_aud_ImpulseResponse_doc,
+	".. class:: ImpulseResponse(sound, /)\n\n"
+	"   An ImpulseResponse object represents a filter with which to convolve a sound.\n\n"
+	"   :arg sound: The sound to use as the impulse response.\n"
+	"   :type sound: :class:`Sound`\n");
+
+PyTypeObject ImpulseResponseType = {
+	PyVarObject_HEAD_INIT(nullptr, 0)
+	"aud.ImpulseResponse",					/* tp_name */
+	sizeof(ImpulseResponseP),				/* tp_basicsize */
+	0,										/* tp_itemsize */
+	(destructor)ImpulseResponse_dealloc,			/* tp_dealloc */
+	0,										/* tp_print */
+	0,										/* tp_getattr */
+	0,										/* tp_setattr */
+	0,										/* tp_reserved */
+	0,										/* tp_repr */
+	0,										/* tp_as_number */
+	0,										/* tp_as_sequence */
+	0,										/* tp_as_mapping */
+	0,										/* tp_hash  */
+	0,										/* tp_call */
+	0,										/* tp_str */
+	0,										/* tp_getattro */
+	0,										/* tp_setattro */
+	0,										/* tp_as_buffer */
+	Py_TPFLAGS_DEFAULT,						/* tp_flags */
+	M_aud_ImpulseResponse_doc,				/* tp_doc */
+	0,										/* tp_traverse */
+	0,										/* tp_clear */
+	0,										/* tp_richcompare */
+	0,										/* tp_weaklistoffset */
+	0,										/* tp_iter */
+	0,										/* tp_iternext */
+	ImpulseResponse_methods,				/* tp_methods */
+	0,										/* tp_members */
+	0,										/* tp_getset */
+	0,										/* tp_base */
+	0,										/* tp_dict */
+	0,										/* tp_descr_get */
+	0,										/* tp_descr_set */
+	0,										/* tp_dictoffset */
+	0,										/* tp_init */
+	0,										/* tp_alloc */
+	ImpulseResponse_new,					/* tp_new */
+};
+
+AUD_API PyObject* ImpulseResponse_empty()
+{
+	return ImpulseResponseType.tp_alloc(&ImpulseResponseType, 0);
+}
+
+
+AUD_API ImpulseResponseP* checkImpulseResponse(PyObject* impulseResponse)
+{
+	if(!PyObject_TypeCheck(impulseResponse, &ImpulseResponseType))
+	{
+		PyErr_SetString(PyExc_TypeError, "Object is not of type ImpulseResponse!");
+		return nullptr;
+	}
+
+	return (ImpulseResponseP*)impulseResponse;
+}
+
+
+bool initializeImpulseResponse()
+{
+	return PyType_Ready(&ImpulseResponseType) >= 0;
+}
+
+
+void addImpulseResponseToModule(PyObject* module)
+{
+	Py_INCREF(&ImpulseResponseType);
+	PyModule_AddObject(module, "ImpulseResponse", (PyObject *)&ImpulseResponseType);
+}

blender-5.2.0/extern/audaspace/bindings/python/PyImpulseResponse.h

@@ -0,0 +1,33 @@
+/*******************************************************************************
+* Copyright 2009-2015 Juan Francisco Crespo Galán
+*
+* 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.
+******************************************************************************/
+
+#pragma once
+
+#include <Python.h>
+#include "Audaspace.h"
+
+typedef void Reference_ImpulseResponse;
+
+typedef struct {
+	PyObject_HEAD
+	Reference_ImpulseResponse* impulseResponse;
+} ImpulseResponseP;
+
+extern AUD_API PyObject* ImpulseResponse_empty();
+extern AUD_API ImpulseResponseP* checkImpulseResponse(PyObject* impulseResponse);
+
+bool initializeImpulseResponse();
+void addImpulseResponseToModule(PyObject* module);

blender-5.2.0/extern/audaspace/bindings/python/PyPlaybackManager.cpp

@@ -0,0 +1,393 @@
+/*******************************************************************************
+* Copyright 2015-2016 Juan Francisco Crespo Galán
+*
+* 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 "PyPlaybackManager.h"
+#include "PySound.h"
+#include "PyHandle.h"
+#include "PyDevice.h"
+
+#include "Exception.h"
+#include "fx/PlaybackManager.h"
+
+extern PyObject* AUDError;
+
+static PyObject *
+PlaybackManager_new(PyTypeObject* type, PyObject* args, PyObject* kwds)
+{
+	PlaybackManagerP* self = (PlaybackManagerP*)type->tp_alloc(type, 0);
+
+	if(self != nullptr)
+	{
+		PyObject* object;
+		if(!PyArg_ParseTuple(args, "O:catKey", &object))
+			return nullptr;
+		Device* device = checkDevice(object);
+
+		try
+		{
+			self->playbackManager = new std::shared_ptr<aud::PlaybackManager>(new aud::PlaybackManager(*reinterpret_cast<std::shared_ptr<aud::IDevice>*>(device->device)));
+		}
+		catch(aud::Exception& e)
+		{
+			Py_DECREF(self);
+			PyErr_SetString(AUDError, e.what());
+			return nullptr;
+		}
+	}
+
+	return (PyObject *)self;
+}
+
+static void
+PlaybackManager_dealloc(PlaybackManagerP* self)
+{
+	if(self->playbackManager)
+		delete reinterpret_cast<std::shared_ptr<aud::PlaybackManager>*>(self->playbackManager);
+	Py_TYPE(self)->tp_free((PyObject *)self);
+}
+
+PyDoc_STRVAR(M_aud_PlaybackManager_play_doc,
+	".. method:: play(sound, catKey)\n\n"
+	"   Plays a sound through the playback manager and assigns it to a category.\n\n"
+	"   :arg sound: The sound to play.\n"
+	"   :type sound: :class:`Sound`\n"
+	"   :arg catKey: the key of the category in which the sound will be added,\n"
+	"      if it doesn't exist, a new one will be created.\n"
+	"   :type catKey: int\n"
+	"   :return: The playback handle with which playback can be controlled with.\n"
+	"   :rtype: :class:`Handle`");
+
+static PyObject *
+PlaybackManager_play(PlaybackManagerP* self, PyObject* args)
+{
+	PyObject* object;
+	unsigned int cat;
+
+	if(!PyArg_ParseTuple(args, "OI:catKey", &object, &cat))
+		return nullptr;
+
+	Sound* sound = checkSound(object);
+	if(!sound)
+		return nullptr;
+
+	Handle* handle;
+
+	handle = (Handle*)Handle_empty();
+	if(handle != nullptr)
+	{
+		try
+		{
+			handle->handle = new std::shared_ptr<aud::IHandle>((*reinterpret_cast<std::shared_ptr<aud::PlaybackManager>*>(self->playbackManager))->play(*reinterpret_cast<std::shared_ptr<aud::ISound>*>(sound->sound), cat));
+		}
+		catch(aud::Exception& e)
+		{
+			Py_DECREF(handle);
+			PyErr_SetString(AUDError, e.what());
+			return nullptr;
+		}
+	}
+
+	return (PyObject *)handle;
+}
+
+PyDoc_STRVAR(M_aud_PlaybackManager_resume_doc,
+	".. method:: resume(catKey)\n\n"
+	"   Resumes playback of the catgory.\n\n"
+	"   :arg catKey: the key of the category.\n"
+	"   :type catKey: int\n"
+	"   :return: Whether the action succeeded.\n"
+	"   :rtype: bool");
+
+static PyObject *
+PlaybackManager_resume(PlaybackManagerP* self, PyObject* args)
+{
+	unsigned int cat;
+
+	if(!PyArg_ParseTuple(args, "I:catKey", &cat))
+		return nullptr;
+
+	try
+	{
+		return PyBool_FromLong((long)(*reinterpret_cast<std::shared_ptr<aud::PlaybackManager>*>(self->playbackManager))->resume(cat));
+	}
+	catch(aud::Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+PyDoc_STRVAR(M_aud_PlaybackManager_pause_doc,
+	".. method:: pause(catKey)\n\n"
+	"   Pauses playback of the category.\n\n"
+	"   :arg catKey: the key of the category.\n"
+	"   :type catKey: int\n"
+	"   :return: Whether the action succeeded.\n"
+	"   :rtype: bool");
+
+static PyObject *
+PlaybackManager_pause(PlaybackManagerP* self, PyObject* args)
+{
+	unsigned int cat;
+
+	if(!PyArg_ParseTuple(args, "I:catKey", &cat))
+		return nullptr;
+
+	try
+	{
+		return PyBool_FromLong((long)(*reinterpret_cast<std::shared_ptr<aud::PlaybackManager>*>(self->playbackManager))->pause(cat));
+	}
+	catch(aud::Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+PyDoc_STRVAR(M_aud_PlaybackManager_add_category_doc,
+	".. method:: addCategory(volume)\n\n"
+	"   Adds a category with a custom volume.\n\n"
+	"   :arg volume: The volume for ther new category.\n"
+	"   :type volume: float\n"
+	"   :return: The key of the new category.\n"
+	"   :rtype: int\n\n");
+
+static PyObject *
+PlaybackManager_add_category(PlaybackManagerP* self, PyObject* args)
+{
+	float vol;
+
+	if(!PyArg_ParseTuple(args, "f:volume", &vol))
+		return nullptr;
+
+	try
+	{
+		return Py_BuildValue("I", (*reinterpret_cast<std::shared_ptr<aud::PlaybackManager>*>(self->playbackManager))->addCategory(vol));
+	}
+	catch(aud::Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+PyDoc_STRVAR(M_aud_PlaybackManager_get_volume_doc,
+	".. method:: getVolume(catKey)\n\n"
+	"   Retrieves the volume of a category.\n\n"
+	"   :arg catKey: the key of the category.\n"
+	"   :type catKey: int\n"
+	"   :return: The volume of the category.\n"
+	"   :rtype: float\n\n");
+
+static PyObject *
+PlaybackManager_get_volume(PlaybackManagerP* self, PyObject* args)
+{
+	unsigned int cat;
+
+	if(!PyArg_ParseTuple(args, "I:catKey", &cat))
+		return nullptr;
+
+	try
+	{
+		return Py_BuildValue("f", (*reinterpret_cast<std::shared_ptr<aud::PlaybackManager>*>(self->playbackManager))->getVolume(cat));
+	}
+	catch(aud::Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+PyDoc_STRVAR(M_aud_PlaybackManager_set_volume_doc,
+	".. method:: setVolume(volume, catKey)\n\n"
+	"   Changes the volume of a category.\n\n"
+	"   :arg volume: the new volume value.\n"
+	"   :type volume: float\n"
+	"   :arg catKey: the key of the category.\n"
+	"   :type catKey: int\n"
+	"   :return: Whether the action succeeded.\n"
+	"   :rtype: int\n\n");
+
+static PyObject *
+PlaybackManager_set_volume(PlaybackManagerP* self, PyObject* args)
+{
+	float volume;
+	unsigned int cat;
+
+	if(!PyArg_ParseTuple(args, "fI:volume", &volume, &cat))
+		return nullptr;
+
+	try
+	{
+		return PyBool_FromLong((long)(*reinterpret_cast<std::shared_ptr<aud::PlaybackManager>*>(self->playbackManager))->setVolume(volume, cat));
+	}
+	catch(aud::Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+PyDoc_STRVAR(M_aud_PlaybackManager_stop_doc,
+	".. method:: stop(catKey)\n\n"
+	"   Stops playback of the category.\n\n"
+	"   :arg catKey: the key of the category.\n"
+	"   :type catKey: int\n"
+	"   :return: Whether the action succeeded.\n"
+	"   :rtype: bool\n\n");
+
+static PyObject *
+PlaybackManager_stop(PlaybackManagerP* self, PyObject* args)
+{
+	unsigned int cat;
+
+	if(!PyArg_ParseTuple(args, "I:catKey", &cat))
+		return nullptr;
+
+	try
+	{
+		return PyBool_FromLong((long)(*reinterpret_cast<std::shared_ptr<aud::PlaybackManager>*>(self->playbackManager))->stop(cat));
+	}
+	catch(aud::Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+PyDoc_STRVAR(M_aud_PlaybackManager_clean_doc,
+	".. method:: clean()\n\n"
+	"   Cleans all the invalid and finished sound from the playback manager.\n\n");
+
+static PyObject *
+PlaybackManager_clean(PlaybackManagerP* self)
+{
+	try
+	{
+		(*reinterpret_cast<std::shared_ptr<aud::PlaybackManager>*>(self->playbackManager))->clean();
+		Py_RETURN_NONE;
+	}
+	catch(aud::Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+static PyMethodDef PlaybackManager_methods[] = {
+	{ "play", (PyCFunction)PlaybackManager_play, METH_VARARGS | METH_KEYWORDS,
+	M_aud_PlaybackManager_play_doc
+	},
+	{ "resume", (PyCFunction)PlaybackManager_resume, METH_VARARGS,
+	M_aud_PlaybackManager_resume_doc
+	},
+	{ "pause", (PyCFunction)PlaybackManager_pause, METH_VARARGS,
+	M_aud_PlaybackManager_pause_doc
+	},
+	{ "stop", (PyCFunction)PlaybackManager_stop, METH_VARARGS,
+	M_aud_PlaybackManager_stop_doc
+	},
+	{ "addCategory", (PyCFunction)PlaybackManager_add_category, METH_VARARGS,
+	M_aud_PlaybackManager_add_category_doc
+	},
+	{ "getVolume", (PyCFunction)PlaybackManager_get_volume, METH_VARARGS,
+	M_aud_PlaybackManager_get_volume_doc
+	},
+	{ "setVolume", (PyCFunction)PlaybackManager_set_volume, METH_VARARGS,
+	M_aud_PlaybackManager_set_volume_doc
+	},
+	{ "clean", (PyCFunction)PlaybackManager_clean, METH_NOARGS,
+	M_aud_PlaybackManager_clean_doc
+	},
+	{ nullptr }  /* Sentinel */
+};
+
+PyDoc_STRVAR(M_aud_PlaybackManager_doc,
+	".. class:: PlaybackManager(device, /)\n\n"
+	"   A PlaybackManager object allows to easily control groups of sounds organized in categories.\n\n"
+	"   :arg device: The device that will be used to play sounds.\n"
+	"   :type device: :class:`Device`\n");
+
+PyTypeObject PlaybackManagerType = {
+	PyVarObject_HEAD_INIT(nullptr, 0)
+	"aud.PlaybackManager",					/* tp_name */
+	sizeof(PlaybackManagerP),				/* tp_basicsize */
+	0,										/* tp_itemsize */
+	(destructor)PlaybackManager_dealloc,	/* tp_dealloc */
+	0,										/* tp_print */
+	0,										/* tp_getattr */
+	0,										/* tp_setattr */
+	0,										/* tp_reserved */
+	0,										/* tp_repr */
+	0,										/* tp_as_number */
+	0,										/* tp_as_sequence */
+	0,										/* tp_as_mapping */
+	0,										/* tp_hash  */
+	0,										/* tp_call */
+	0,										/* tp_str */
+	0,										/* tp_getattro */
+	0,										/* tp_setattro */
+	0,										/* tp_as_buffer */
+	Py_TPFLAGS_DEFAULT,						/* tp_flags */
+	M_aud_PlaybackManager_doc,				/* tp_doc */
+	0,										/* tp_traverse */
+	0,										/* tp_clear */
+	0,										/* tp_richcompare */
+	0,										/* tp_weaklistoffset */
+	0,										/* tp_iter */
+	0,										/* tp_iternext */
+	PlaybackManager_methods,				/* tp_methods */
+	0,										/* tp_members */
+	0,										/* tp_getset */
+	0,										/* tp_base */
+	0,										/* tp_dict */
+	0,										/* tp_descr_get */
+	0,										/* tp_descr_set */
+	0,										/* tp_dictoffset */
+	0,										/* tp_init */
+	0,										/* tp_alloc */
+	PlaybackManager_new,					/* tp_new */
+};
+
+AUD_API PyObject* PlaybackManager_empty()
+{
+	return PlaybackManagerType.tp_alloc(&PlaybackManagerType, 0);
+}
+
+
+AUD_API PlaybackManagerP* checkPlaybackManager(PyObject* playbackManager)
+{
+	if(!PyObject_TypeCheck(playbackManager, &PlaybackManagerType))
+	{
+		PyErr_SetString(PyExc_TypeError, "Object is not of type PlaybackManager!");
+		return nullptr;
+	}
+
+	return (PlaybackManagerP*)playbackManager;
+}
+
+
+bool initializePlaybackManager()
+{
+	return PyType_Ready(&PlaybackManagerType) >= 0;
+}
+
+
+void addPlaybackManagerToModule(PyObject* module)
+{
+	Py_INCREF(&PlaybackManagerType);
+	PyModule_AddObject(module, "PlaybackManager", (PyObject *)&PlaybackManagerType);
+}

blender-5.2.0/extern/audaspace/bindings/python/PyPlaybackManager.h

@@ -0,0 +1,33 @@
+/*******************************************************************************
+* Copyright 2015-2016 Juan Francisco Crespo Galán
+*
+* 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.
+******************************************************************************/
+
+#pragma once
+
+#include <Python.h>
+#include "Audaspace.h"
+
+typedef void Reference_PlaybackManager;
+
+typedef struct {
+	PyObject_HEAD
+	Reference_PlaybackManager* playbackManager;
+} PlaybackManagerP;
+
+extern AUD_API PyObject* PlaybackManager_empty();
+extern AUD_API PlaybackManagerP* checkPlaybackManager(PyObject* playbackManager);
+
+bool initializePlaybackManager();
+void addPlaybackManagerToModule(PyObject* module);

blender-5.2.0/extern/audaspace/bindings/python/PySequence.cpp

@@ -0,0 +1,664 @@
+/*******************************************************************************
+ * 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 "PySequence.h"
+
+#include "PySound.h"
+#include "PySequenceEntry.h"
+
+#include "sequence/AnimateableProperty.h"
+#include "sequence/Sequence.h"
+#include "Exception.h"
+
+#include <vector>
+#include <structmember.h>
+
+using aud::Channels;
+using aud::DistanceModel;
+using aud::Exception;
+using aud::ISound;
+using aud::AnimateableProperty;
+using aud::AnimateablePropertyType;
+using aud::Specs;
+
+extern PyObject* AUDError;
+
+// ====================================================================
+
+static void
+Sequence_dealloc(Sequence* self)
+{
+	if(self->sequence)
+		delete reinterpret_cast<std::shared_ptr<aud::Sequence>*>(self->sequence);
+	Py_TYPE(self)->tp_free((PyObject *)self);
+}
+
+static PyObject *
+Sequence_new(PyTypeObject* type, PyObject* args, PyObject* kwds)
+{
+	Sequence* self;
+
+	int channels = aud::CHANNELS_STEREO;
+	double rate = aud::RATE_48000;
+	float fps = 30.0f;
+	bool muted = false;
+	PyObject* mutedo = nullptr;
+
+	self = (Sequence*)type->tp_alloc(type, 0);
+	if(self != nullptr)
+	{
+		static const char* kwlist[] = {"channels", "rate", "fps", "muted", nullptr};
+
+		if(!PyArg_ParseTupleAndKeywords(args, kwds, "|idfO:Sequence", const_cast<char**>(kwlist), &channels, &rate, &fps, &mutedo))
+		{
+			Py_DECREF(self);
+			return nullptr;
+		}
+
+		if(mutedo)
+		{
+			if(!PyBool_Check(mutedo))
+			{
+				PyErr_SetString(PyExc_TypeError, "muted is not a boolean!");
+				return nullptr;
+			}
+
+			muted = mutedo == Py_True;
+		}
+
+		aud::Specs specs;
+		specs.channels = static_cast<aud::Channels>(channels);
+		specs.rate = rate;
+
+		try
+		{
+			self->sequence = new std::shared_ptr<aud::Sequence>(new aud::Sequence(specs, fps, muted));
+		}
+		catch(Exception& e)
+		{
+			Py_DECREF(self);
+			PyErr_SetString(AUDError, e.what());
+			return nullptr;
+		}
+	}
+
+	return (PyObject *)self;
+}
+
+PyDoc_STRVAR(M_aud_Sequence_add_doc,
+			 ".. method:: add()\n\n"
+			 "   Adds a new entry to the sequence.\n\n"
+			 "   :arg sound: The sound this entry should play.\n"
+			 "   :type sound: :class:`Sound`\n"
+			 "   :arg begin: The start time.\n"
+			 "   :type begin: double\n"
+			 "   :arg end: The end time or a negative value if determined by the sound.\n"
+			 "   :type end: double\n"
+			 "   :arg skip: How much seconds should be skipped at the beginning.\n"
+			 "   :type skip: double\n"
+			 "   :return: The entry added.\n"
+			 "   :rtype: :class:`SequenceEntry`");
+
+static PyObject *
+Sequence_add(Sequence* self, PyObject* args, PyObject* kwds)
+{
+	PyObject* object;
+	double begin;
+	double end = -1.0;
+	double skip = 0.0;
+
+	static const char* kwlist[] = {"sound", "begin", "end", "skip", nullptr};
+
+	if(!PyArg_ParseTupleAndKeywords(args, kwds, "Od|dd:add", const_cast<char**>(kwlist), &object, &begin, &end, &skip))
+		return nullptr;
+
+	Sound* sound = checkSound(object);
+
+	if(!sound)
+		return nullptr;
+
+	SequenceEntry* entry;
+
+	entry = (SequenceEntry*)SequenceEntry_empty();
+	if(entry != nullptr)
+	{
+		try
+		{
+			entry->entry = new std::shared_ptr<aud::SequenceEntry>((*reinterpret_cast<std::shared_ptr<aud::Sequence>*>(self->sequence))->add(*reinterpret_cast<std::shared_ptr<ISound>*>(sound->sound), begin, end, skip));
+		}
+		catch(Exception& e)
+		{
+			Py_DECREF(entry);
+			PyErr_SetString(AUDError, e.what());
+			return nullptr;
+		}
+	}
+
+	return (PyObject *)entry;
+}
+
+PyDoc_STRVAR(M_aud_Sequence_remove_doc,
+			 ".. method:: remove()\n\n"
+			 "   Removes an entry from the sequence.\n\n"
+			 "   :arg entry: The entry to remove.\n"
+			 "   :type entry: :class:`SequenceEntry`\n");
+
+static PyObject *
+Sequence_remove(Sequence* self, PyObject* args)
+{
+	PyObject* object;
+
+	if(!PyArg_ParseTuple(args, "O:remove", &object))
+		return nullptr;
+
+	SequenceEntry* entry = checkSequenceEntry(object);
+
+	if(!entry)
+		return nullptr;
+
+	try
+	{
+		(*reinterpret_cast<std::shared_ptr<aud::Sequence>*>(self->sequence))->remove(*reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(entry->entry));
+		Py_RETURN_NONE;
+	}
+	catch(Exception& e)
+	{
+		Py_DECREF(entry);
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+PyDoc_STRVAR(M_aud_Sequence_setAnimationData_doc,
+			 ".. method:: setAnimationData()\n\n"
+			 "   Writes animation data to a sequence.\n\n"
+			 "   :arg type: The type of animation data.\n"
+			 "   :type type: int\n"
+			 "   :arg frame: The frame this data is for.\n"
+			 "   :type frame: int\n"
+			 "   :arg data: The data to write.\n"
+			 "   :type data: sequence of float\n"
+			 "   :arg animated: Whether the attribute is animated.\n"
+			 "   :type animated: bool");
+
+static PyObject *
+Sequence_setAnimationData(Sequence* self, PyObject* args)
+{
+	int type, frame;
+	PyObject* py_data;
+	Py_ssize_t py_data_len;
+	PyObject* animatedo;
+	bool animated;
+
+	if(!PyArg_ParseTuple(args, "iiOO:setAnimationData", &type, &frame, &py_data, &animatedo))
+		return nullptr;
+
+	if(!PySequence_Check(py_data))
+	{
+		PyErr_SetString(PyExc_TypeError, "Parameter is not a sequence!");
+		return nullptr;
+	}
+
+	py_data_len= PySequence_Size(py_data);
+	
+	std::vector<float> data;
+	data.reserve(py_data_len);
+
+	PyObject* py_value;
+	float value;
+
+	for(Py_ssize_t i = 0; i < py_data_len; i++)
+	{
+		py_value = PySequence_GetItem(py_data, i);
+		value= (float)PyFloat_AsDouble(py_value);
+		Py_DECREF(py_value);
+
+		if(value == -1.0f && PyErr_Occurred()) {
+			return nullptr;
+		}
+
+		data.push_back(value);
+	}
+
+	if(!PyBool_Check(animatedo))
+	{
+		PyErr_SetString(PyExc_TypeError, "animated is not a boolean!");
+		return nullptr;
+	}
+
+	animated = animatedo == Py_True;
+
+	try
+	{
+		AnimateableProperty* prop = (*reinterpret_cast<std::shared_ptr<aud::Sequence>*>(self->sequence))->getAnimProperty(static_cast<AnimateablePropertyType>(type));
+
+		if(prop->getCount() != py_data_len)
+		{
+			PyErr_SetString(PyExc_ValueError, "the amount of floats doesn't fit the animated property");
+			return nullptr;
+		}
+
+		if(animated)
+		{
+			if(frame >= 0)
+				prop->write(&data[0], frame, 1);
+		}
+		else
+		{
+			prop->write(&data[0]);
+		}
+		Py_RETURN_NONE;
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+static PyMethodDef Sequence_methods[] = {
+	{"add", (PyCFunction)Sequence_add, METH_VARARGS | METH_KEYWORDS,
+	 M_aud_Sequence_add_doc
+	},
+	{"remove", (PyCFunction)Sequence_remove, METH_VARARGS,
+	 M_aud_Sequence_remove_doc
+	},
+	{"setAnimationData", (PyCFunction)Sequence_setAnimationData, METH_VARARGS,
+	 M_aud_Sequence_setAnimationData_doc
+	},
+	{nullptr}  /* Sentinel */
+};
+
+PyDoc_STRVAR(M_aud_Sequence_channels_doc,
+			 "The channel count of the sequence.");
+
+static PyObject *
+Sequence_get_channels(Sequence* self, void* nothing)
+{
+	try
+	{
+		Specs specs = (*reinterpret_cast<std::shared_ptr<aud::Sequence>*>(self->sequence))->getSpecs();
+		return Py_BuildValue("i", specs.channels);
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+static int
+Sequence_set_channels(Sequence* self, PyObject* args, void* nothing)
+{
+	int channels;
+
+	if(!PyArg_Parse(args, "i:channels", &channels))
+		return -1;
+
+	try
+	{
+		std::shared_ptr<aud::Sequence> sequence = *reinterpret_cast<std::shared_ptr<aud::Sequence>*>(self->sequence);
+		Specs specs = sequence->getSpecs();
+		specs.channels = static_cast<Channels>(channels);
+		sequence->setSpecs(specs);
+		return 0;
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return -1;
+	}
+}
+
+PyDoc_STRVAR(M_aud_Sequence_distance_model_doc,
+			 "The distance model of the sequence.\n\n"
+			  ".. seealso:: `OpenAL Documentation <https://www.openal.org/documentation/>`__");
+
+static PyObject *
+Sequence_get_distance_model(Sequence* self, void* nothing)
+{
+	try
+	{
+		return Py_BuildValue("i", (*reinterpret_cast<std::shared_ptr<aud::Sequence>*>(self->sequence))->getDistanceModel());
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+static int
+Sequence_set_distance_model(Sequence* self, PyObject* args, void* nothing)
+{
+	int distance_model;
+
+	if(!PyArg_Parse(args, "i:distance_model", &distance_model))
+		return -1;
+
+	try
+	{
+		(*reinterpret_cast<std::shared_ptr<aud::Sequence>*>(self->sequence))->setDistanceModel(static_cast<DistanceModel>(distance_model));
+		return 0;
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return -1;
+	}
+}
+
+PyDoc_STRVAR(M_aud_Sequence_doppler_factor_doc,
+			 "The doppler factor of the sequence.\n"
+			 "This factor is a scaling factor for the velocity vectors in "
+			 "doppler calculation. So a value bigger than 1 will exaggerate "
+			 "the effect as it raises the velocity.");
+
+static PyObject *
+Sequence_get_doppler_factor(Sequence* self, void* nothing)
+{
+	try
+	{
+		return Py_BuildValue("f", (*reinterpret_cast<std::shared_ptr<aud::Sequence>*>(self->sequence))->getDopplerFactor());
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+static int
+Sequence_set_doppler_factor(Sequence* self, PyObject* args, void* nothing)
+{
+	float factor;
+
+	if(!PyArg_Parse(args, "f:doppler_factor", &factor))
+		return -1;
+
+	try
+	{
+		(*reinterpret_cast<std::shared_ptr<aud::Sequence>*>(self->sequence))->setDopplerFactor(factor);
+		return 0;
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return -1;
+	}
+}
+
+PyDoc_STRVAR(M_aud_Sequence_fps_doc,
+			 "The listeners's location in 3D space, a 3D tuple of floats.");
+
+static PyObject *
+Sequence_get_fps(Sequence* self, void* nothing)
+{
+	try
+	{
+		return Py_BuildValue("f", (*reinterpret_cast<std::shared_ptr<aud::Sequence>*>(self->sequence))->getFPS());
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+static int
+Sequence_set_fps(Sequence* self, PyObject* args, void* nothing)
+{
+	float fps;
+
+	if(!PyArg_Parse(args, "f:fps", &fps))
+		return -1;
+
+	try
+	{
+		(*reinterpret_cast<std::shared_ptr<aud::Sequence>*>(self->sequence))->setFPS(fps);
+		return 0;
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return -1;
+	}
+}
+
+PyDoc_STRVAR(M_aud_Sequence_muted_doc,
+			 "Whether the whole sequence is muted.\n");
+
+static PyObject *
+Sequence_get_muted(Sequence* self, void* nothing)
+{
+	try
+	{
+		std::shared_ptr<aud::Sequence>* sequence = reinterpret_cast<std::shared_ptr<aud::Sequence>*>(self->sequence);
+		return PyBool_FromLong((long)(*sequence)->isMuted());
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+static int
+Sequence_set_muted(Sequence* self, PyObject* args, void* nothing)
+{
+	if(!PyBool_Check(args))
+	{
+		PyErr_SetString(PyExc_TypeError, "muted is not a boolean!");
+		return -1;
+	}
+
+	bool muted = args == Py_True;
+
+	try
+	{
+		std::shared_ptr<aud::Sequence>* sequence = reinterpret_cast<std::shared_ptr<aud::Sequence>*>(self->sequence);
+		(*sequence)->mute(muted);
+		return 0;
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+	}
+
+	return -1;
+}
+
+PyDoc_STRVAR(M_aud_Sequence_rate_doc,
+			 "The sampling rate of the sequence in Hz.");
+
+static PyObject *
+Sequence_get_rate(Sequence* self, void* nothing)
+{
+	try
+	{
+		Specs specs = (*reinterpret_cast<std::shared_ptr<aud::Sequence>*>(self->sequence))->getSpecs();
+		return Py_BuildValue("d", specs.rate);
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+static int
+Sequence_set_rate(Sequence* self, PyObject* args, void* nothing)
+{
+	double rate;
+
+	if(!PyArg_Parse(args, "d:rate", &rate))
+		return -1;
+
+	try
+	{
+		std::shared_ptr<aud::Sequence> sequence = *reinterpret_cast<std::shared_ptr<aud::Sequence>*>(self->sequence);
+		Specs specs = sequence->getSpecs();
+		specs.rate = rate;
+		sequence->setSpecs(specs);
+		return 0;
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return -1;
+	}
+}
+
+PyDoc_STRVAR(M_aud_Sequence_speed_of_sound_doc,
+			 "The speed of sound of the sequence.\n"
+			 "The speed of sound in air is typically 343.3 m/s.");
+
+static PyObject *
+Sequence_get_speed_of_sound(Sequence* self, void* nothing)
+{
+	try
+	{
+		return Py_BuildValue("f", (*reinterpret_cast<std::shared_ptr<aud::Sequence>*>(self->sequence))->getSpeedOfSound());
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+static int
+Sequence_set_speed_of_sound(Sequence* self, PyObject* args, void* nothing)
+{
+	float speed;
+
+	if(!PyArg_Parse(args, "f:speed_of_sound", &speed))
+		return -1;
+
+	try
+	{
+		(*reinterpret_cast<std::shared_ptr<aud::Sequence>*>(self->sequence))->setSpeedOfSound(speed);
+		return 0;
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return -1;
+	}
+}
+
+static PyGetSetDef Sequence_properties[] = {
+	{(char*)"channels", (getter)Sequence_get_channels, (setter)Sequence_set_channels,
+	 M_aud_Sequence_channels_doc, nullptr },
+	{(char*)"distance_model", (getter)Sequence_get_distance_model, (setter)Sequence_set_distance_model,
+	 M_aud_Sequence_distance_model_doc, nullptr },
+	{(char*)"doppler_factor", (getter)Sequence_get_doppler_factor, (setter)Sequence_set_doppler_factor,
+	 M_aud_Sequence_doppler_factor_doc, nullptr },
+	{(char*)"fps", (getter)Sequence_get_fps, (setter)Sequence_set_fps,
+	 M_aud_Sequence_fps_doc, nullptr },
+	{(char*)"muted", (getter)Sequence_get_muted, (setter)Sequence_set_muted,
+	 M_aud_Sequence_muted_doc, nullptr },
+	{(char*)"rate", (getter)Sequence_get_rate, (setter)Sequence_set_rate,
+	 M_aud_Sequence_rate_doc, nullptr },
+	{(char*)"speed_of_sound", (getter)Sequence_get_speed_of_sound, (setter)Sequence_set_speed_of_sound,
+	 M_aud_Sequence_speed_of_sound_doc, nullptr },
+	{nullptr}  /* Sentinel */
+};
+
+PyDoc_STRVAR(M_aud_Sequence_doc,
+			 ".. class:: Sequence(channels=2, rate=48000.0, fps=30.0, muted=False)\n\n"
+			 "   This sound represents sequenced entries to play a sound sequence.\n\n"
+			 "   :arg channels: The number of channels.\n"
+			 "   :type channels: int\n"
+			 "   :arg rate: The sample rate in Hz.\n"
+			 "   :type rate: double\n"
+			 "   :arg fps: The frames per second of the sequence.\n"
+			 "   :type fps: float\n"
+			 "   :arg muted: Whether the sequence is muted.\n"
+			 "   :type muted: bool\n");
+
+extern PyTypeObject SoundType;
+
+static PyTypeObject SequenceType = {
+	PyVarObject_HEAD_INIT(nullptr, 0)
+	"aud.Sequence",              /* tp_name */
+	sizeof(Sequence),            /* tp_basicsize */
+	0,                           /* tp_itemsize */
+	(destructor)Sequence_dealloc,/* tp_dealloc */
+	0,                           /* tp_print */
+	0,                           /* tp_getattr */
+	0,                           /* tp_setattr */
+	0,                           /* tp_reserved */
+	0,                           /* tp_repr */
+	0,                           /* tp_as_number */
+	0,                           /* tp_as_sequence */
+	0,                           /* tp_as_mapping */
+	0,                           /* tp_hash  */
+	0,                           /* tp_call */
+	0,                           /* tp_str */
+	0,                           /* tp_getattro */
+	0,                           /* tp_setattro */
+	0,                           /* tp_as_buffer */
+	Py_TPFLAGS_DEFAULT,          /* tp_flags */
+	M_aud_Sequence_doc,          /* tp_doc */
+	0,		                     /* tp_traverse */
+	0,		                     /* tp_clear */
+	0,		                     /* tp_richcompare */
+	0,		                     /* tp_weaklistoffset */
+	0,		                     /* tp_iter */
+	0,		                     /* tp_iternext */
+	Sequence_methods,            /* tp_methods */
+	0,                           /* tp_members */
+	Sequence_properties,         /* tp_getset */
+	&SoundType,                  /* tp_base */
+	0,                           /* tp_dict */
+	0,                           /* tp_descr_get */
+	0,                           /* tp_descr_set */
+	0,                           /* tp_dictoffset */
+	0,                           /* tp_init */
+	0,                           /* tp_alloc */
+	Sequence_new,                /* tp_new */
+};
+
+AUD_API PyObject* Sequence_empty()
+{
+	return SequenceType.tp_alloc(&SequenceType, 0);
+}
+
+
+AUD_API Sequence* checkSequence(PyObject* sequence)
+{
+	if(!PyObject_TypeCheck(sequence, &SequenceType))
+	{
+		PyErr_SetString(PyExc_TypeError, "Object is not of type Sequence!");
+		return nullptr;
+	}
+
+	return (Sequence*)sequence;
+}
+
+
+bool initializeSequence()
+{
+	return PyType_Ready(&SequenceType) >= 0;
+}
+
+
+void addSequenceToModule(PyObject* module)
+{
+	Py_INCREF(&SequenceType);
+	PyModule_AddObject(module, "Sequence", (PyObject *)&SequenceType);
+}

blender-5.2.0/extern/audaspace/bindings/python/PySequence.h

@@ -0,0 +1,33 @@
+/*******************************************************************************
+ * 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.
+ ******************************************************************************/
+
+#pragma once
+
+#include <Python.h>
+#include "Audaspace.h"
+
+typedef void Reference_Sequence;
+
+typedef struct {
+	PyObject_HEAD
+	Reference_Sequence* sequence;
+} Sequence;
+
+extern AUD_API PyObject* Sequence_empty();
+extern AUD_API Sequence* checkSequence(PyObject* sequence);
+
+bool initializeSequence();
+void addSequenceToModule(PyObject* module);

blender-5.2.0/extern/audaspace/bindings/python/PySequenceEntry.cpp

@@ -0,0 +1,740 @@
+/*******************************************************************************
+ * 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 "PySequenceEntry.h"
+
+#include "PySound.h"
+
+#include "Exception.h"
+#include "sequence/AnimateableProperty.h"
+#include "sequence/SequenceEntry.h"
+
+#include <structmember.h>
+#include <vector>
+
+using aud::Exception;
+using aud::AnimateableProperty;
+using aud::AnimateablePropertyType;
+using aud::ISound;
+
+extern PyObject* AUDError;
+
+// ====================================================================
+
+static void
+SequenceEntry_dealloc(SequenceEntry* self)
+{
+	if(self->entry)
+		delete reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
+	Py_TYPE(self)->tp_free((PyObject *)self);
+}
+
+PyDoc_STRVAR(M_aud_SequenceEntry_move_doc,
+			 ".. method:: move()\n\n"
+			 "   Moves the entry.\n\n"
+			 "   :arg begin: The new start time.\n"
+			 "   :type begin: double\n"
+			 "   :arg end: The new end time or a negative value if unknown.\n"
+			 "   :type end: double\n"
+			 "   :arg skip: How many seconds to skip at the beginning.\n"
+			 "   :type skip: double\n");
+
+static PyObject *
+SequenceEntry_move(SequenceEntry* self, PyObject* args)
+{
+	double begin, end, skip;
+
+	if(!PyArg_ParseTuple(args, "ddd:move", &begin, &end, &skip))
+		return nullptr;
+
+	try
+	{
+		(*reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry))->move(begin, end, skip);
+		Py_RETURN_NONE;
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+PyDoc_STRVAR(M_aud_SequenceEntry_setAnimationData_doc,
+			 ".. method:: setAnimationData()\n\n"
+			 "   Writes animation data to a sequenced entry.\n\n"
+			 "   :arg type: The type of animation data.\n"
+			 "   :type type: int\n"
+			 "   :arg frame: The frame this data is for.\n"
+			 "   :type frame: int\n"
+			 "   :arg data: The data to write.\n"
+			 "   :type data: sequence of float\n"
+			 "   :arg animated: Whether the attribute is animated.\n"
+			 "   :type animated: bool");
+
+static PyObject *
+SequenceEntry_setAnimationData(SequenceEntry* self, PyObject* args)
+{
+	int type, frame;
+	PyObject* py_data;
+	Py_ssize_t py_data_len;
+	PyObject* animatedo;
+	bool animated;
+
+	if(!PyArg_ParseTuple(args, "iiOO:setAnimationData", &type, &frame, &py_data, &animatedo))
+		return nullptr;
+
+	if(!PySequence_Check(py_data))
+	{
+		PyErr_SetString(PyExc_TypeError, "Parameter is not a sequence!");
+		return nullptr;
+	}
+
+	py_data_len= PySequence_Size(py_data);
+
+	std::vector<float> data;
+	data.reserve(py_data_len);
+
+	PyObject* py_value;
+	float value;
+
+	for(Py_ssize_t i = 0; i < py_data_len; i++)
+	{
+		py_value = PySequence_GetItem(py_data, i);
+		value= (float)PyFloat_AsDouble(py_value);
+		Py_DECREF(py_value);
+
+		if(value == -1.0f && PyErr_Occurred()) {
+			return nullptr;
+		}
+
+		data.push_back(value);
+	}
+
+	if(!PyBool_Check(animatedo))
+	{
+		PyErr_SetString(PyExc_TypeError, "animated is not a boolean!");
+		return nullptr;
+	}
+
+	animated = animatedo == Py_True;
+
+	try
+	{
+		AnimateableProperty* prop = (*reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry))->getAnimProperty(static_cast<AnimateablePropertyType>(type));
+
+		if(prop->getCount() != py_data_len)
+		{
+			PyErr_SetString(PyExc_ValueError, "the amount of floats doesn't fit the animated property");
+			return nullptr;
+		}
+
+		if(animated)
+		{
+			if(frame >= 0)
+				prop->write(&data[0], frame, 1);
+		}
+		else
+		{
+			prop->write(&data[0]);
+		}
+		Py_RETURN_NONE;
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+static PyMethodDef SequenceEntry_methods[] = {
+	{"move", (PyCFunction)SequenceEntry_move, METH_VARARGS,
+	 M_aud_SequenceEntry_move_doc
+	},
+	{"setAnimationData", (PyCFunction)SequenceEntry_setAnimationData, METH_VARARGS,
+	 M_aud_SequenceEntry_setAnimationData_doc
+	},
+	{nullptr}  /* Sentinel */
+};
+
+PyDoc_STRVAR(M_aud_SequenceEntry_attenuation_doc,
+			 "This factor is used for distance based attenuation of the "
+			 "source.\n\n"
+			 ".. seealso:: :attr:`Device.distance_model`");
+
+static PyObject *
+SequenceEntry_get_attenuation(SequenceEntry* self, void* nothing)
+{
+	try
+	{
+		std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
+		return Py_BuildValue("f", (*entry)->getAttenuation());
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+static int
+SequenceEntry_set_attenuation(SequenceEntry* self, PyObject* args, void* nothing)
+{
+	float factor;
+
+	if(!PyArg_Parse(args, "f:attenuation", &factor))
+		return -1;
+
+	try
+	{
+		std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
+		(*entry)->setAttenuation(factor);
+		return 0;
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+	}
+
+	return -1;
+}
+
+PyDoc_STRVAR(M_aud_SequenceEntry_cone_angle_inner_doc,
+			 "The opening angle of the inner cone of the source. If the cone "
+			 "values of a source are set there are two (audible) cones with "
+			 "the apex at the :attr:`location` of the source and with infinite "
+			 "height, heading in the direction of the source's "
+			 ":attr:`orientation`.\n"
+			 "In the inner cone the volume is normal. Outside the outer cone "
+			 "the volume will be :attr:`cone_volume_outer` and in the area "
+			 "between the volume will be interpolated linearly.");
+
+static PyObject *
+SequenceEntry_get_cone_angle_inner(SequenceEntry* self, void* nothing)
+{
+	try
+	{
+		std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
+		return Py_BuildValue("f", (*entry)->getConeAngleInner());
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+static int
+SequenceEntry_set_cone_angle_inner(SequenceEntry* self, PyObject* args, void* nothing)
+{
+	float angle;
+
+	if(!PyArg_Parse(args, "f:cone_angle_inner", &angle))
+		return -1;
+
+	try
+	{
+		std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
+		(*entry)->setConeAngleInner(angle);
+		return 0;
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+	}
+
+	return -1;
+}
+
+PyDoc_STRVAR(M_aud_SequenceEntry_cone_angle_outer_doc,
+			 "The opening angle of the outer cone of the source.\n\n"
+			 ".. seealso:: :attr:`cone_angle_inner`");
+
+static PyObject *
+SequenceEntry_get_cone_angle_outer(SequenceEntry* self, void* nothing)
+{
+	try
+	{
+		std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
+		return Py_BuildValue("f", (*entry)->getConeAngleOuter());
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+static int
+SequenceEntry_set_cone_angle_outer(SequenceEntry* self, PyObject* args, void* nothing)
+{
+	float angle;
+
+	if(!PyArg_Parse(args, "f:cone_angle_outer", &angle))
+		return -1;
+
+	try
+	{
+		std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
+		(*entry)->setConeAngleOuter(angle);
+		return 0;
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+	}
+
+	return -1;
+}
+
+PyDoc_STRVAR(M_aud_SequenceEntry_cone_volume_outer_doc,
+			 "The volume outside the outer cone of the source.\n\n"
+			 ".. seealso:: :attr:`cone_angle_inner`");
+
+static PyObject *
+SequenceEntry_get_cone_volume_outer(SequenceEntry* self, void* nothing)
+{
+	try
+	{
+		std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
+		return Py_BuildValue("f", (*entry)->getConeVolumeOuter());
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+static int
+SequenceEntry_set_cone_volume_outer(SequenceEntry* self, PyObject* args, void* nothing)
+{
+	float volume;
+
+	if(!PyArg_Parse(args, "f:cone_volume_outer", &volume))
+		return -1;
+
+	try
+	{
+		std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
+		(*entry)->setConeVolumeOuter(volume);
+		return 0;
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+	}
+
+	return -1;
+}
+
+PyDoc_STRVAR(M_aud_SequenceEntry_distance_maximum_doc,
+			 "The maximum distance of the source.\n"
+			 "If the listener is further away the source volume will be 0.\n\n"
+			 ".. seealso:: :attr:`Device.distance_model`");
+
+static PyObject *
+SequenceEntry_get_distance_maximum(SequenceEntry* self, void* nothing)
+{
+	try
+	{
+		std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
+		return Py_BuildValue("f", (*entry)->getDistanceMaximum());
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+static int
+SequenceEntry_set_distance_maximum(SequenceEntry* self, PyObject* args, void* nothing)
+{
+	float distance;
+
+	if(!PyArg_Parse(args, "f:distance_maximum", &distance))
+		return -1;
+
+	try
+	{
+		std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
+		(*entry)->setDistanceMaximum(distance);
+		return 0;
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+	}
+
+	return -1;
+}
+
+PyDoc_STRVAR(M_aud_SequenceEntry_distance_reference_doc,
+			 "The reference distance of the source.\n"
+			 "At this distance the volume will be exactly :attr:`volume`.\n\n"
+			 ".. seealso:: :attr:`Device.distance_model`");
+
+static PyObject *
+SequenceEntry_get_distance_reference(SequenceEntry* self, void* nothing)
+{
+	try
+	{
+		std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
+		return Py_BuildValue("f", (*entry)->getDistanceReference());
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+static int
+SequenceEntry_set_distance_reference(SequenceEntry* self, PyObject* args, void* nothing)
+{
+	float distance;
+
+	if(!PyArg_Parse(args, "f:distance_reference", &distance))
+		return -1;
+
+	try
+	{
+		std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
+		(*entry)->setDistanceReference(distance);
+		return 0;
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+	}
+
+	return -1;
+}
+
+PyDoc_STRVAR(M_aud_SequenceEntry_muted_doc,
+			 "Whether the entry is muted.\n");
+
+static PyObject *
+SequenceEntry_get_muted(SequenceEntry* self, void* nothing)
+{
+	try
+	{
+		std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
+		return PyBool_FromLong((long)(*entry)->isMuted());
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+static int
+SequenceEntry_set_muted(SequenceEntry* self, PyObject* args, void* nothing)
+{
+	if(!PyBool_Check(args))
+	{
+		PyErr_SetString(PyExc_TypeError, "muted is not a boolean!");
+		return -1;
+	}
+
+	bool muted = args == Py_True;
+
+	try
+	{
+		std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
+		(*entry)->mute(muted);
+		return 0;
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+	}
+
+	return -1;
+}
+
+PyDoc_STRVAR(M_aud_SequenceEntry_relative_doc,
+			 "Whether the source's location, velocity and orientation is relative or absolute to the listener.");
+
+static PyObject *
+SequenceEntry_get_relative(SequenceEntry* self, void* nothing)
+{
+	try
+	{
+		std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
+		return PyBool_FromLong((long)(*entry)->isRelative());
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+	}
+
+	return nullptr;
+}
+
+static int
+SequenceEntry_set_relative(SequenceEntry* self, PyObject* args, void* nothing)
+{
+	if(!PyBool_Check(args))
+	{
+		PyErr_SetString(PyExc_TypeError, "Value is not a boolean!");
+		return -1;
+	}
+
+	bool relative = (args == Py_True);
+
+	try
+	{
+		std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
+		(*entry)->setRelative(relative);
+		return 0;
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+	}
+
+	return -1;
+}
+
+PyDoc_STRVAR(M_aud_SequenceEntry_sound_doc,
+			 "The sound the entry is representing and will be played in the sequence.");
+
+static PyObject *
+SequenceEntry_get_sound(SequenceEntry* self, void* nothing)
+{
+	try
+	{
+		std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
+		Sound* object = (Sound*) Sound_empty();
+		if(object)
+		{
+			object->sound = new std::shared_ptr<ISound>((*entry)->getSound());
+			return (PyObject *) object;
+		}
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+	}
+
+	return nullptr;
+}
+
+static int
+SequenceEntry_set_sound(SequenceEntry* self, PyObject* args, void* nothing)
+{
+	Sound* sound = checkSound(args);
+
+	if(!sound)
+		return -1;
+
+	try
+	{
+		std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
+		(*entry)->setSound(*reinterpret_cast<std::shared_ptr<ISound>*>(sound->sound));
+		return 0;
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+	}
+
+	return -1;
+}
+
+PyDoc_STRVAR(M_aud_SequenceEntry_volume_maximum_doc,
+			 "The maximum volume of the source.\n\n"
+			 ".. seealso:: :attr:`Device.distance_model`");
+
+static PyObject *
+SequenceEntry_get_volume_maximum(SequenceEntry* self, void* nothing)
+{
+	try
+	{
+		std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
+		return Py_BuildValue("f", (*entry)->getVolumeMaximum());
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+static int
+SequenceEntry_set_volume_maximum(SequenceEntry* self, PyObject* args, void* nothing)
+{
+	float volume;
+
+	if(!PyArg_Parse(args, "f:volume_maximum", &volume))
+		return -1;
+
+	try
+	{
+		std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
+		(*entry)->setVolumeMaximum(volume);
+		return 0;
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+	}
+
+	return -1;
+}
+
+PyDoc_STRVAR(M_aud_SequenceEntry_volume_minimum_doc,
+			 "The minimum volume of the source.\n\n"
+			 ".. seealso:: :attr:`Device.distance_model`");
+
+static PyObject *
+SequenceEntry_get_volume_minimum(SequenceEntry* self, void* nothing)
+{
+	try
+	{
+		std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
+		return Py_BuildValue("f", (*entry)->getVolumeMinimum());
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+static int
+SequenceEntry_set_volume_minimum(SequenceEntry* self, PyObject* args, void* nothing)
+{
+	float volume;
+
+	if(!PyArg_Parse(args, "f:volume_minimum", &volume))
+		return -1;
+
+	try
+	{
+		std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
+		(*entry)->setVolumeMinimum(volume);
+		return 0;
+	}
+	catch(Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+	}
+
+	return -1;
+}
+
+static PyGetSetDef SequenceEntry_properties[] = {
+	{(char*)"attenuation", (getter)SequenceEntry_get_attenuation, (setter)SequenceEntry_set_attenuation,
+	 M_aud_SequenceEntry_attenuation_doc, nullptr },
+	{(char*)"cone_angle_inner", (getter)SequenceEntry_get_cone_angle_inner, (setter)SequenceEntry_set_cone_angle_inner,
+	 M_aud_SequenceEntry_cone_angle_inner_doc, nullptr },
+	{(char*)"cone_angle_outer", (getter)SequenceEntry_get_cone_angle_outer, (setter)SequenceEntry_set_cone_angle_outer,
+	 M_aud_SequenceEntry_cone_angle_outer_doc, nullptr },
+	{(char*)"cone_volume_outer", (getter)SequenceEntry_get_cone_volume_outer, (setter)SequenceEntry_set_cone_volume_outer,
+	 M_aud_SequenceEntry_cone_volume_outer_doc, nullptr },
+	{(char*)"distance_maximum", (getter)SequenceEntry_get_distance_maximum, (setter)SequenceEntry_set_distance_maximum,
+	 M_aud_SequenceEntry_distance_maximum_doc, nullptr },
+	{(char*)"distance_reference", (getter)SequenceEntry_get_distance_reference, (setter)SequenceEntry_set_distance_reference,
+	 M_aud_SequenceEntry_distance_reference_doc, nullptr },
+	{(char*)"muted", (getter)SequenceEntry_get_muted, (setter)SequenceEntry_set_muted,
+	 M_aud_SequenceEntry_muted_doc, nullptr },
+	{(char*)"relative", (getter)SequenceEntry_get_relative, (setter)SequenceEntry_set_relative,
+	 M_aud_SequenceEntry_relative_doc, nullptr },
+	{(char*)"sound", (getter)SequenceEntry_get_sound, (setter)SequenceEntry_set_sound,
+	 M_aud_SequenceEntry_sound_doc, nullptr },
+	{(char*)"volume_maximum", (getter)SequenceEntry_get_volume_maximum, (setter)SequenceEntry_set_volume_maximum,
+	 M_aud_SequenceEntry_volume_maximum_doc, nullptr },
+	{(char*)"volume_minimum", (getter)SequenceEntry_get_volume_minimum, (setter)SequenceEntry_set_volume_minimum,
+	 M_aud_SequenceEntry_volume_minimum_doc, nullptr },
+	{nullptr}  /* Sentinel */
+};
+
+PyDoc_STRVAR(M_aud_SequenceEntry_doc,
+			 "SequenceEntry objects represent an entry of a sequenced sound.");
+
+static PyTypeObject SequenceEntryType = {
+	PyVarObject_HEAD_INIT(nullptr, 0)
+	"aud.SequenceEntry",               /* tp_name */
+	sizeof(SequenceEntry),             /* tp_basicsize */
+	0,                                 /* tp_itemsize */
+	(destructor)SequenceEntry_dealloc, /* tp_dealloc */
+	0,                                 /* tp_print */
+	0,                                 /* tp_getattr */
+	0,                                 /* tp_setattr */
+	0,                                 /* tp_reserved */
+	0,                                 /* tp_repr */
+	0,                                 /* tp_as_number */
+	0,                                 /* tp_as_sequence */
+	0,                                 /* tp_as_mapping */
+	0,                                 /* tp_hash  */
+	0,                                 /* tp_call */
+	0,                                 /* tp_str */
+	0,                                 /* tp_getattro */
+	0,                                 /* tp_setattro */
+	0,                                 /* tp_as_buffer */
+	Py_TPFLAGS_DEFAULT,                /* tp_flags */
+	M_aud_SequenceEntry_doc,           /* tp_doc */
+	0,                                 /* tp_traverse */
+	0,                                 /* tp_clear */
+	0,                                 /* tp_richcompare */
+	0,                                 /* tp_weaklistoffset */
+	0,                                 /* tp_iter */
+	0,                                 /* tp_iternext */
+	SequenceEntry_methods,             /* tp_methods */
+	0,                                 /* tp_members */
+	SequenceEntry_properties,          /* tp_getset */
+	0,                                 /* tp_base */
+	0,                                 /* tp_dict */
+	0,                                 /* tp_descr_get */
+	0,                                 /* tp_descr_set */
+	0,                                 /* tp_dictoffset */
+	0,                                 /* tp_init */
+	0,                                 /* tp_alloc */
+	0,                                 /* tp_new */
+};
+
+AUD_API PyObject* SequenceEntry_empty()
+{
+	return SequenceEntryType.tp_alloc(&SequenceEntryType, 0);
+}
+
+
+AUD_API SequenceEntry* checkSequenceEntry(PyObject* entry)
+{
+	if(!PyObject_TypeCheck(entry, &SequenceEntryType))
+	{
+		PyErr_SetString(PyExc_TypeError, "Object is not of type SequenceEntry!");
+		return nullptr;
+	}
+
+	return (SequenceEntry*)entry;
+}
+
+
+bool initializeSequenceEntry()
+{
+	return PyType_Ready(&SequenceEntryType) >= 0;
+}
+
+
+void addSequenceEntryToModule(PyObject* module)
+{
+	Py_INCREF(&SequenceEntryType);
+	PyModule_AddObject(module, "SequenceEntry", (PyObject *)&SequenceEntryType);
+}

blender-5.2.0/extern/audaspace/bindings/python/PySequenceEntry.h

@@ -0,0 +1,33 @@
+/*******************************************************************************
+ * 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.
+ ******************************************************************************/
+
+#pragma once
+
+#include <Python.h>
+#include "Audaspace.h"
+
+typedef void Reference_SequenceEntry;
+
+typedef struct {
+	PyObject_HEAD
+	Reference_SequenceEntry* entry;
+} SequenceEntry;
+
+extern AUD_API PyObject* SequenceEntry_empty();
+extern AUD_API SequenceEntry* checkSequenceEntry(PyObject* entry);
+
+bool initializeSequenceEntry();
+void addSequenceEntryToModule(PyObject* module);

blender-5.2.0/extern/audaspace/bindings/python/PySound.h

@@ -0,0 +1,33 @@
+/*******************************************************************************
+ * 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.
+ ******************************************************************************/
+
+#pragma once
+
+#include <Python.h>
+#include "Audaspace.h"
+
+typedef void Reference_ISound;
+
+typedef struct {
+	PyObject_HEAD
+	Reference_ISound* sound;
+} Sound;
+
+extern AUD_API PyObject* Sound_empty();
+extern AUD_API Sound* checkSound(PyObject* sound);
+
+bool initializeSound();
+void addSoundToModule(PyObject* module);

blender-5.2.0/extern/audaspace/bindings/python/PySource.cpp

@@ -0,0 +1,267 @@
+/*******************************************************************************
+* Copyright 2009-2015 Juan Francisco Crespo Galán
+*
+* 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 "PySource.h"
+
+#include "Exception.h"
+#include "fx/Source.h"
+
+#include <memory>
+
+extern PyObject* AUDError;
+
+static PyObject *
+Source_new(PyTypeObject* type, PyObject* args, PyObject* kwds)
+{
+	SourceP* self = (SourceP*)type->tp_alloc(type, 0);
+
+	if(self != nullptr)
+	{
+		float azimuth, elevation, distance;
+		if(!PyArg_ParseTuple(args, "fff:angles", &azimuth, &elevation, &distance))
+			return nullptr;
+
+		try
+		{
+			self->source = new std::shared_ptr<aud::Source>(new aud::Source(azimuth, elevation, distance));
+		}
+		catch(aud::Exception& e)
+		{
+			Py_DECREF(self);
+			PyErr_SetString(AUDError, e.what());
+			return nullptr;
+		}
+	}
+
+	return (PyObject *)self;
+}
+
+static void
+Source_dealloc(SourceP* self)
+{
+	if(self->source)
+		delete reinterpret_cast<std::shared_ptr<aud::Source>*>(self->source);
+	Py_TYPE(self)->tp_free((PyObject *)self);
+}
+
+static PyMethodDef Source_methods[] = {
+	{ nullptr }  /* Sentinel */
+};
+
+PyDoc_STRVAR(M_aud_Source_azimuth_doc,
+	"The azimuth angle.");
+
+static int
+Source_set_azimuth(SourceP* self, PyObject* args, void* nothing)
+{
+	float azimuth;
+
+	if(!PyArg_Parse(args, "f:azimuth", &azimuth))
+		return -1;
+
+	try
+	{
+		(*reinterpret_cast<std::shared_ptr<aud::Source>*>(self->source))->setAzimuth(azimuth);
+		return 0;
+	}
+	catch(aud::Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+	}
+
+	return -1;
+}
+
+static PyObject *
+Source_get_azimuth(SourceP* self, void* nothing)
+{
+	try
+	{
+		return Py_BuildValue("f", (*reinterpret_cast<std::shared_ptr<aud::Source>*>(self->source))->getAzimuth());
+	}
+	catch(aud::Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+PyDoc_STRVAR(M_aud_Source_elevation_doc,
+	"The elevation angle.");
+
+static int
+Source_set_elevation(SourceP* self, PyObject* args, void* nothing)
+{
+	float elevation;
+
+	if(!PyArg_Parse(args, "f:elevation", &elevation))
+		return -1;
+
+	try
+	{
+		(*reinterpret_cast<std::shared_ptr<aud::Source>*>(self->source))->setElevation(elevation);
+		return 0;
+	}
+	catch(aud::Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+	}
+
+	return -1;
+}
+
+static PyObject *
+Source_get_elevation(SourceP* self, void* nothing)
+{
+	try
+	{
+		return Py_BuildValue("f", (*reinterpret_cast<std::shared_ptr<aud::Source>*>(self->source))->getElevation());
+	}
+	catch(aud::Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+PyDoc_STRVAR(M_aud_Source_distance_doc,
+	"The distance value. 0 is min, 1 is max.");
+
+static int
+Source_set_distance(SourceP* self, PyObject* args, void* nothing)
+{
+	float distance;
+
+	if(!PyArg_Parse(args, "f:distance", &distance))
+		return -1;
+
+	try
+	{
+		(*reinterpret_cast<std::shared_ptr<aud::Source>*>(self->source))->setDistance(distance);
+		return 0;
+	}
+	catch(aud::Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+	}
+
+	return -1;
+}
+
+static PyObject *
+Source_get_distance(SourceP* self, void* nothing)
+{
+	try
+	{
+		return Py_BuildValue("f", (*reinterpret_cast<std::shared_ptr<aud::Source>*>(self->source))->getDistance());
+	}
+	catch(aud::Exception& e)
+	{
+		PyErr_SetString(AUDError, e.what());
+		return nullptr;
+	}
+}
+
+static PyGetSetDef Source_properties[] = {
+	{ (char*)"azimuth", (getter)Source_get_azimuth, (setter)Source_set_azimuth,
+	M_aud_Source_azimuth_doc, nullptr },
+	{ (char*)"elevation", (getter)Source_get_elevation, (setter)Source_set_elevation,
+	M_aud_Source_elevation_doc, nullptr },
+	{ (char*)"distance", (getter)Source_get_distance, (setter)Source_set_distance,
+	M_aud_Source_distance_doc, nullptr },
+	{ nullptr }  /* Sentinel */
+};
+
+PyDoc_STRVAR(M_aud_Source_doc,
+	".. class:: Source(azimuth, elevation, distance, /)\n\n"
+	"   The source object represents the source position of a binaural sound.\n\n"
+	"   :arg azimuth: The azimuth angle in degrees.\n"
+	"   :type azimuth: float\n"
+	"   :arg elevation: The elevation angle in degrees.\n"
+	"   :type elevation: float\n"
+	"   :arg distance: The distance of the source.\n"
+	"   :type distance: float\n");
+
+PyTypeObject SourceType = {
+	PyVarObject_HEAD_INIT(nullptr, 0)
+	"aud.Source",							/* tp_name */
+	sizeof(SourceP),						/* tp_basicsize */
+	0,										/* tp_itemsize */
+	(destructor)Source_dealloc,				/* tp_dealloc */
+	0,										/* tp_print */
+	0,										/* tp_getattr */
+	0,										/* tp_setattr */
+	0,										/* tp_reserved */
+	0,										/* tp_repr */
+	0,										/* tp_as_number */
+	0,										/* tp_as_sequence */
+	0,										/* tp_as_mapping */
+	0,										/* tp_hash  */
+	0,										/* tp_call */
+	0,										/* tp_str */
+	0,										/* tp_getattro */
+	0,										/* tp_setattro */
+	0,										/* tp_as_buffer */
+	Py_TPFLAGS_DEFAULT,						/* tp_flags */
+	M_aud_Source_doc,						/* tp_doc */
+	0,										/* tp_traverse */
+	0,										/* tp_clear */
+	0,										/* tp_richcompare */
+	0,										/* tp_weaklistoffset */
+	0,										/* tp_iter */
+	0,										/* tp_iternext */
+	Source_methods,							/* tp_methods */
+	0,										/* tp_members */
+	Source_properties,						/* tp_getset */
+	0,										/* tp_base */
+	0,										/* tp_dict */
+	0,										/* tp_descr_get */
+	0,										/* tp_descr_set */
+	0,										/* tp_dictoffset */
+	0,										/* tp_init */
+	0,										/* tp_alloc */
+	Source_new,								/* tp_new */
+};
+
+AUD_API PyObject* Source_empty()
+{
+	return SourceType.tp_alloc(&SourceType, 0);
+}
+
+
+AUD_API SourceP* checkSource(PyObject* source)
+{
+	if(!PyObject_TypeCheck(source, &SourceType))
+	{
+		PyErr_SetString(PyExc_TypeError, "Object is not of type Source!");
+		return nullptr;
+	}
+
+	return (SourceP*)source;
+}
+
+
+bool initializeSource()
+{
+	return PyType_Ready(&SourceType) >= 0;
+}
+
+
+void addSourceToModule(PyObject* module)
+{
+	Py_INCREF(&SourceType);
+	PyModule_AddObject(module, "Source", (PyObject *)&SourceType);
+}

blender-5.2.0/extern/audaspace/bindings/python/PySource.h

@@ -0,0 +1,33 @@
+/*******************************************************************************
+* Copyright 2009-2015 Juan Francisco Crespo Galán
+*
+* 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.
+******************************************************************************/
+
+#pragma once
+
+#include <Python.h>
+#include "Audaspace.h"
+
+typedef void Reference_Source;
+
+typedef struct {
+	PyObject_HEAD
+		Reference_Source* source;
+} SourceP;
+
+extern AUD_API PyObject* Source_empty();
+extern AUD_API SourceP* checkSource(PyObject* source);
+
+bool initializeSource();
+void addSourceToModule(PyObject* module);

blender-5.2.0/extern/audaspace/bindings/python/PyThreadPool.cpp

@@ -0,0 +1,137 @@
+/*******************************************************************************
+* Copyright 2009-2015 Juan Francisco Crespo Galán
+*
+* 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 "PyThreadPool.h"
+
+#include "Exception.h"
+#include "util/ThreadPool.h"
+
+extern PyObject* AUDError;
+
+static PyObject *
+ThreadPool_new(PyTypeObject* type, PyObject* args, PyObject* kwds)
+{
+	ThreadPoolP* self = (ThreadPoolP*)type->tp_alloc(type, 0);
+
+	if(self != nullptr)
+	{
+		unsigned int nThreads;
+		if(!PyArg_ParseTuple(args, "I:nThreads", &nThreads))
+			return nullptr;
+
+		try
+		{
+			self->threadPool = new std::shared_ptr<aud::ThreadPool>(new aud::ThreadPool(nThreads));
+		}
+		catch(aud::Exception& e)
+		{
+			Py_DECREF(self);
+			PyErr_SetString(AUDError, e.what());
+			return nullptr;
+		}
+	}
+
+	return (PyObject *)self;
+}
+
+static void
+ThreadPool_dealloc(ThreadPoolP* self)
+{
+	if(self->threadPool)
+		delete reinterpret_cast<std::shared_ptr<aud::ThreadPool>*>(self->threadPool);
+	Py_TYPE(self)->tp_free((PyObject *)self);
+}
+
+static PyMethodDef ThreadPool_methods[] = {
+	{ nullptr }  /* Sentinel */
+};
+
+PyDoc_STRVAR(M_aud_ThreadPool_doc,
+	".. class:: ThreadPool(nThreads, /)\n\n"
+	"   A ThreadPool is used to parallelize convolution efficiently.\n\n"
+	"   :arg nThreads: The number of threads in the pool.\n"
+	"   :type nThreads: int\n");
+
+PyTypeObject ThreadPoolType = {
+	PyVarObject_HEAD_INIT(nullptr, 0)
+	"aud.ThreadPool",						/* tp_name */
+	sizeof(ThreadPoolP),					/* tp_basicsize */
+	0,										/* tp_itemsize */
+	(destructor)ThreadPool_dealloc,			/* tp_dealloc */
+	0,										/* tp_print */
+	0,										/* tp_getattr */
+	0,										/* tp_setattr */
+	0,										/* tp_reserved */
+	0,										/* tp_repr */
+	0,										/* tp_as_number */
+	0,										/* tp_as_sequence */
+	0,										/* tp_as_mapping */
+	0,										/* tp_hash  */
+	0,										/* tp_call */
+	0,										/* tp_str */
+	0,										/* tp_getattro */
+	0,										/* tp_setattro */
+	0,										/* tp_as_buffer */
+	Py_TPFLAGS_DEFAULT,						/* tp_flags */
+	M_aud_ThreadPool_doc,					/* tp_doc */
+	0,										/* tp_traverse */
+	0,										/* tp_clear */
+	0,										/* tp_richcompare */
+	0,										/* tp_weaklistoffset */
+	0,										/* tp_iter */
+	0,										/* tp_iternext */
+	ThreadPool_methods,						/* tp_methods */
+	0,										/* tp_members */
+	0,										/* tp_getset */
+	0,										/* tp_base */
+	0,										/* tp_dict */
+	0,										/* tp_descr_get */
+	0,										/* tp_descr_set */
+	0,										/* tp_dictoffset */
+	0,										/* tp_init */
+	0,										/* tp_alloc */
+	ThreadPool_new,							/* tp_new */
+};
+
+AUD_API PyObject* ThreadPool_empty()
+{
+	return ThreadPoolType.tp_alloc(&ThreadPoolType, 0);
+}
+
+
+AUD_API ThreadPoolP* checkThreadPool(PyObject* threadPool)
+{
+	if(!PyObject_TypeCheck(threadPool, &ThreadPoolType))
+	{
+		PyErr_SetString(PyExc_TypeError, "Object is not of type ThreadPool!");
+		return nullptr;
+	}
+
+	return (ThreadPoolP*)threadPool;
+}
+
+
+bool initializeThreadPool()
+{
+	return PyType_Ready(&ThreadPoolType) >= 0;
+}
+
+
+void addThreadPoolToModule(PyObject* module)
+{
+	Py_INCREF(&ThreadPoolType);
+	PyModule_AddObject(module, "ThreadPool", (PyObject *)&ThreadPoolType);
+}

blender-5.2.0/extern/audaspace/bindings/python/PyThreadPool.h

@@ -0,0 +1,33 @@
+/*******************************************************************************
+* Copyright 2009-2015 Juan Francisco Crespo Galán
+*
+* 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.
+******************************************************************************/
+
+#pragma once
+
+#include <Python.h>
+#include "Audaspace.h"
+
+typedef void Reference_ThreadPool;
+
+typedef struct {
+	PyObject_HEAD
+		Reference_ThreadPool* threadPool;
+} ThreadPoolP;
+
+extern AUD_API PyObject* ThreadPool_empty();
+extern AUD_API ThreadPoolP* checkThreadPool(PyObject* ThreadPool);
+
+bool initializeThreadPool();
+void addThreadPoolToModule(PyObject* module);

blender-5.2.0/extern/audaspace/bindings/python/examples/binaural.py

@@ -0,0 +1,13 @@
+#!/usr/bin/python
+import aud, sys, time, multiprocessing
+device = aud.Device()
+hrtf = aud.HRTF().loadLeftHrtfSet(".wav", sys.argv[2])
+threadPool = aud.ThreadPool(multiprocessing.cpu_count())
+source = aud.Source(0, 0, 0)
+sound = aud.Sound.file(sys.argv[1]).rechannel(1).binaural(hrtf, source, threadPool)
+handle = device.play(sound)
+
+while handle.status:
+    source.azimuth += 1
+    print("Azimuth: " + str(source.azimuth))
+    time.sleep(0.1)

blender-5.2.0/extern/audaspace/bindings/python/examples/convolution.py

@@ -0,0 +1,10 @@
+#!/usr/bin/python
+import aud, sys, time, multiprocessing
+device = aud.Device()
+ir = aud.ImpulseResponse(aud.Sound.file(sys.argv[2]))
+threadPool = aud.ThreadPool(multiprocessing.cpu_count())
+sound = aud.Sound.file(sys.argv[1]).convolver(ir, threadPool)
+handle = device.play(sound)
+handle.volume = 0.1
+while handle.status:
+    time.sleep(0.1)

blender-5.2.0/extern/audaspace/bindings/python/examples/dynamicmusic.py

@@ -0,0 +1,20 @@
+import aud, sys, time
+
+device=aud.Device()
+dMusic = aud.DynamicMusic(device)
+sound1 = aud.Sound.file(sys.argv[1])
+sound2 = aud.Sound.file(sys.argv[2])
+effect = aud.Sound.file(sys.argv[3])
+
+dMusic.addScene(sound1)
+dMusic.addScene(sound2)
+dMusic.addTransition(1,2,effect)
+
+dMusic.fadeTime=3
+dMusic.volume=0.5
+
+dMusic.scene=1
+time.sleep(5)
+dMusic.scene=2
+
+time.sleep(500)

blender-5.2.0/extern/audaspace/bindings/python/examples/playbackmanager.py

@@ -0,0 +1,27 @@
+import aud, sys, time
+
+device=aud.Device()
+manager = aud.PlaybackManager(device)
+sound1 = aud.Sound.file(sys.argv[1])
+sound2 = aud.Sound.file(sys.argv[2])
+sound3 = aud.Sound.file(sys.argv[3])
+sound4 = aud.Sound.file(sys.argv[4])
+
+manager.play(sound1, 0)
+manager.play(sound2, 0)
+manager.play(sound3, 1)
+manager.play(sound4, 1)
+
+manager.setVolume(0.2, 0)
+time.sleep(5)
+manager.setVolume(0.0, 1)
+time.sleep(5)
+manager.pause(0)
+time.sleep(5)
+manager.setVolume(0.5, 1)
+manager.setVolume(1.0, 0)
+time.sleep(5)
+manager.stop(1)
+manager.resume(0)
+
+time.sleep(500)

blender-5.2.0/extern/audaspace/bindings/python/examples/player.py

@@ -0,0 +1,7 @@
+#!/usr/bin/python
+import aud, sys, time
+device = aud.Device()
+sound = aud.Sound.file(sys.argv[1])
+handle = device.play(sound)
+while handle.status:
+	time.sleep(0.1)

blender-5.2.0/extern/audaspace/bindings/python/examples/randomSounds.py

@@ -0,0 +1,21 @@
+import aud, sys, time
+
+device=aud.Device()
+sound1 = aud.Sound.file(sys.argv[1])
+sound2 = aud.Sound.file(sys.argv[2])
+sound3 = aud.Sound.file(sys.argv[3])
+sound4 = aud.Sound.file(sys.argv[4])
+list=aud.Sound.list(True)
+
+list.addSound(sound1)
+list.addSound(sound2)
+list.addSound(sound3)
+list.addSound(sound4)
+mutable=aud.Sound.mutable(list)
+
+device.lock()
+handle=device.play(mutable)
+handle.loop_count=2
+device.unlock()
+
+time.sleep(500)

blender-5.2.0/extern/audaspace/bindings/python/examples/simple.py

@@ -0,0 +1,7 @@
+#!/usr/bin/python
+import aud, time
+device = aud.Device()
+sine = aud.Sound.sine(440)
+square = sine.threshold()
+handle = device.play(square)
+time.sleep(3)

blender-5.2.0/extern/audaspace/bindings/python/examples/siren.py

@@ -0,0 +1,19 @@
+#!/usr/bin/python
+import aud, math, time
+length = 0.5
+fadelength = 0.05
+
+device = aud.Device()
+high = aud.Sound.sine(880).limit(0, length).fadein(0, fadelength).fadeout(length - fadelength, length)
+low = aud.Sound.sine(700).limit(0, length).fadein(0, fadelength).fadeout(length - fadelength, length).volume(0.6)
+sound = high.join(low)
+handle = device.play(sound)
+handle.loop_count = -1
+
+start = time.time()
+
+while time.time() - start < 10:
+	angle = time.time() - start
+
+	handle.location = [math.sin(angle), 0, -math.cos(angle)]
+

blender-5.2.0/extern/audaspace/bindings/python/examples/siren2.py

@@ -0,0 +1,23 @@
+#!/usr/bin/python
+import aud, math, time
+length = 0.5
+fadelength = 0.05
+runtime = 10
+distance = 100
+velocity = 2 * distance / runtime
+
+device = aud.Device()
+high = aud.Sound.sine(880).limit(0, length).fadein(0, fadelength).fadeout(length - fadelength, length)
+low = aud.Sound.sine(700).limit(0, length).fadein(0, fadelength).fadeout(length - fadelength, length).volume(0.6)
+sound = high.join(low)
+handle = device.play(sound)
+handle.loop_count = -1
+
+handle.velocity = [velocity, 0, 0]
+
+start = time.time()
+
+while time.time() - start < runtime:
+	location = -distance + velocity * (time.time() - start)
+
+	handle.location = [location, 10, 0]

blender-5.2.0/extern/audaspace/bindings/python/examples/tetris.py

@@ -0,0 +1,66 @@
+#!/usr/bin/python
+import aud, math, time
+ 
+def parseNotes(notes, bpm, basefreq, rate = 44100,
+               notechars = "XXXCXDXEFXGXAXHcXdXefXgXaXhp"):
+	pos = 0
+	fadelength = 60/bpm/10
+	halfchars = "#b"
+	durationchars = "2345678"
+	sound = None
+ 
+	while pos < len(notes):
+		char = notes[pos]
+		mod = None
+		dur = 1
+		pos += 1
+		while pos < len(notes) and notes[pos] not in notechars:
+			if notes[pos] in halfchars:
+				mod = notes[pos]
+			elif notes[pos] in durationchars:
+				dur = notes[pos]
+			pos += 1
+ 
+		freq = notechars.find(char)
+		if mod == '#':
+			freq += 1
+		elif mod == 'b':
+			freq -= 1
+ 
+		freq = math.pow(2, freq/12)*basefreq
+		length = float(dur)*60/bpm
+ 
+		snd = aud.Sound.square(freq, rate)
+		if char == 'p':
+			snd = snd.volume(0)
+		snd = snd.limit(0, length)
+		snd = snd.fadein(0, fadelength)
+		snd = snd.fadeout(length - fadelength, fadelength)
+ 
+		if sound:
+			sound = sound.join(snd)
+		else:
+			sound = snd
+	return sound
+ 
+def tetris(bpm = 300, freq = 220, rate = 44100):
+	notes = "e2Hcd2cH A2Ace2dc H3cd2e2 c2A2A4 pd2fa2gf e3ce2dc H2Hcd2e2 c2A2A2p2"
+	s11 = parseNotes(notes, bpm, freq, rate)
+ 
+	notes = "e4c4 d4H4 c4A4 G#4p4 e4c4 d4H4 A2c2a4 g#4p4"
+	s12 = parseNotes(notes, bpm, freq, rate)
+ 
+	notes = "EeEeEeEe AaAaAaAa AbabAbabAbabAbab AaAaAAHC DdDdDdDd CcCcCcCc HhHhHhHh AaAaA2p2"
+	s21 = parseNotes(notes, bpm, freq, rate, notechars = "AXHCXDXEFXGXaXhcXdXefXgXp")
+ 
+	notes = "aeaeaeae g#dg#dg#dg#d aeaeaeae g#dg#dg#2p2 aeaeaeae g#dg#dg#dg#d aeaeaeae g#dg#dg#2p2"
+	s22 = parseNotes(notes, bpm, freq/2, rate)
+ 
+	return s11.join(s12).join(s11).volume(0.5).mix(s21.join(s22).join(s21).volume(0.3))
+ 
+if __name__ == "__main__":
+	dev = aud.Device()
+	handle = dev.play(tetris(300, 220, dev.rate))
+	while handle.status:
+		time.sleep(0.1)
+

blender-5.2.0/extern/audaspace/bindings/python/examples/tetris2.py

@@ -0,0 +1,64 @@
+#!/usr/bin/python
+import aud, math, time
+ 
+def parseNotes(notes, bpm, basefreq, rate = 44100,
+               notechars = "XXXCXDXEFXGXAXHcXdXefXgXaXhp"):
+	pos = 0
+	fadelength = 60/bpm/10
+	halfchars = "#b"
+	durationchars = "2345678"
+	position = 0
+	sequence = aud.Sequence()
+ 
+	while pos < len(notes):
+		char = notes[pos]
+		mod = None
+		dur = 1
+		pos += 1
+		while pos < len(notes) and notes[pos] not in notechars:
+			if notes[pos] in halfchars:
+				mod = notes[pos]
+			elif notes[pos] in durationchars:
+				dur = notes[pos]
+			pos += 1
+ 
+		freq = notechars.find(char)
+		if mod == '#':
+			freq += 1
+		elif mod == 'b':
+			freq -= 1
+ 
+		freq = math.pow(2, freq/12)*basefreq
+		length = float(dur)*60/bpm
+ 
+		note = aud.Sound.square(freq, rate).fadein(0, fadelength).fadeout(length - fadelength, fadelength)
+ 
+		entry = sequence.add(note, position, position + length, 0)
+		if char == 'p':
+			entry.muted = True
+
+		position += length
+
+	return sequence.limit(0, position)
+ 
+def tetris(bpm = 300, freq = 220, rate = 44100):
+	notes = "e2Hcd2cH A2Ace2dc H3cd2e2 c2A2A4 pd2fa2gf e3ce2dc H2Hcd2e2 c2A2A2p2"
+	s11 = parseNotes(notes, bpm, freq, rate)
+ 
+	notes = "e4c4 d4H4 c4A4 G#4p4 e4c4 d4H4 A2c2a4 g#4p4"
+	s12 = parseNotes(notes, bpm, freq, rate)
+ 
+	notes = "EeEeEeEe AaAaAaAa AbabAbabAbabAbab AaAaAAHC DdDdDdDd CcCcCcCc HhHhHhHh AaAaA2p2"
+	s21 = parseNotes(notes, bpm, freq, rate, notechars = "AXHCXDXEFXGXaXhcXdXefXgXp")
+ 
+	notes = "aeaeaeae g#dg#dg#dg#d aeaeaeae g#dg#dg#2p2 aeaeaeae g#dg#dg#dg#d aeaeaeae g#dg#dg#2p2"
+	s22 = parseNotes(notes, bpm, freq/2, rate)
+ 
+	return s11.join(s12).join(s11).volume(0.5).mix(s21.join(s22).join(s21).volume(0.3))
+ 
+if __name__ == "__main__":
+	dev = aud.Device()
+	handle = dev.play(tetris(300, 220, dev.rate))
+	while handle.status:
+		time.sleep(0.1)
+

blender-5.2.0/extern/audaspace/bindings/python/examples/tetris3.py

@@ -0,0 +1,63 @@
+#!/usr/bin/python
+import aud, math, time
+ 
+def parseNotes(notes, bpm, basefreq, rate = 44100,
+               notechars = "XXXCXDXEFXGXAXHcXdXefXgXaXhp"):
+	pos = 0
+	fadelength = 60/bpm/10
+	halfchars = "#b"
+	durationchars = "2345678"
+	position = 0
+	sequence = aud.Sequence()
+ 
+	while pos < len(notes):
+		char = notes[pos]
+		mod = None
+		dur = 1
+		pos += 1
+		while pos < len(notes) and notes[pos] not in notechars:
+			if notes[pos] in halfchars:
+				mod = notes[pos]
+			elif notes[pos] in durationchars:
+				dur = notes[pos]
+			pos += 1
+ 
+		freq = notechars.find(char)
+		if mod == '#':
+			freq += 1
+		elif mod == 'b':
+			freq -= 1
+ 
+		freq = math.pow(2, freq/12)*basefreq
+		length = float(dur)*60/bpm
+
+		if char != 'p':
+			note = aud.Sound.square(freq, rate).fadein(0, fadelength).fadeout(length - fadelength, fadelength)
+ 
+			sequence.add(note, position, position + length, 0)
+
+		position += length
+
+	return sequence.limit(0, position)
+ 
+def tetris(bpm = 300, freq = 220, rate = 44100):
+	notes = "e2Hcd2cH A2Ace2dc H3cd2e2 c2A2A4 pd2fa2gf e3ce2dc H2Hcd2e2 c2A2A2p2"
+	s11 = parseNotes(notes, bpm, freq, rate)
+ 
+	notes = "e4c4 d4H4 c4A4 G#4p4 e4c4 d4H4 A2c2a4 g#4p4"
+	s12 = parseNotes(notes, bpm, freq, rate)
+ 
+	notes = "EeEeEeEe AaAaAaAa AbabAbabAbabAbab AaAaAAHC DdDdDdDd CcCcCcCc HhHhHhHh AaAaA2p2"
+	s21 = parseNotes(notes, bpm, freq, rate, notechars = "AXHCXDXEFXGXaXhcXdXefXgXp")
+ 
+	notes = "aeaeaeae g#dg#dg#dg#d aeaeaeae g#dg#dg#2p2 aeaeaeae g#dg#dg#dg#d aeaeaeae g#dg#dg#2p2"
+	s22 = parseNotes(notes, bpm, freq/2, rate)
+ 
+	return s11.join(s12).join(s11).volume(0.5).mix(s21.join(s22).join(s21).volume(0.3))
+ 
+if __name__ == "__main__":
+	dev = aud.Device()
+	handle = dev.play(tetris(300, 220, dev.rate))
+	while handle.status:
+		time.sleep(0.1)
+

blender-5.2.0/extern/audaspace/bindings/python/setup.py.in

@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*-
+
+import sys
+import os
+import codecs
+import numpy
+
+from setuptools import setup, Extension
+
+if len(sys.argv) > 2 and sys.argv[1] == '--build-docs':
+    import subprocess
+    from setuptools import Distribution
+    from setuptools.command.build import build
+
+    dist = Distribution()
+    cmd = build(dist)
+    cmd.finalize_options()
+    #print(cmd.build_platlib)
+
+    os.environ['PYTHONPATH'] = os.path.join(os.getcwd(), cmd.build_platlib)
+    os.environ['LD_LIBRARY_PATH'] = os.getcwd()
+
+    ret = subprocess.call(sys.argv[2:])
+    sys.exit(ret)
+
+
+# the following line is not working due to https://bugs.python.org/issue9023
+#source_directory = os.path.relpath('@PYTHON_SOURCE_DIRECTORY@')
+source_directory = '@PYTHON_SOURCE_DIRECTORY@'
+
+extra_args = []
+
+if sys.platform == 'win32':
+    extra_args.append('/EHsc')
+    extra_args.append('/DAUD_BUILD_SHARED_LIBRARY')
+else:
+    extra_args.append('-std=c++17')
+
+macros = []
+
+if '@WITH_FFTW@' == 'ON':
+    macros.append(('WITH_CONVOLUTION', None))
+
+if '@WITH_RUBBERBAND@' == 'ON':
+    macros.append(('WITH_RUBBERBAND', None))
+
+audaspace = Extension(
+                      'aud',
+                      include_dirs = ['@CMAKE_CURRENT_BINARY_DIR@', os.path.join(source_directory, '../../include'), numpy.get_include()] + (['@FFTW_INCLUDE_DIR@'] if '@WITH_FFTW@' == 'ON' else []),
+                      libraries = ['audaspace'],
+                      library_dirs = ['.', 'Release', 'Debug'],
+                      language = 'c++',
+                      extra_compile_args = extra_args,
+                      define_macros = macros,
+                      sources = [os.path.join(source_directory, file) for file in ['PyAnimateableProperty.cpp', 'PyAPI.cpp', 'PyDevice.cpp', 'PyHandle.cpp', 'PySound.cpp', 'PySequenceEntry.cpp', 'PySequence.cpp', 'PyPlaybackManager.cpp', 'PyDynamicMusic.cpp', 'PyThreadPool.cpp', 'PySource.cpp'] + (['PyImpulseResponse.cpp', 'PyHRTF.cpp'] if '@WITH_FFTW@' == 'ON' else [])]
+)
+
+setup(
+      name = 'audaspace',
+      version = '@AUDASPACE_LONG_VERSION@',
+      description = 'Audaspace is a high level audio library.',
+      author = 'Jörg Müller',
+      author_email = 'nexyon@gmail.com',
+      url = 'https://github.com/audaspace/audaspace',
+      license = 'Apache License 2.0',
+      long_description = codecs.open(os.path.join(source_directory, '../../README.md'), 'r', 'utf-8').read(),
+      ext_modules = [audaspace],
+      headers = [os.path.join(source_directory, file) for file in ['PyAnimateableProperty.h', 'PyAPI.h', 'PyDevice.h', 'PyHandle.h', 'PySound.h', 'PySequenceEntry.h', 'PySequence.h', 'PyPlaybackManager.h', 'PyDynamicMusic.h', 'PyThreadPool.h', 'PySource.h'] + (['PyImpulseResponse.h', 'PyHRTF.h'] if '@WITH_FFTW@' == 'ON' else [])] + ['Audaspace.h']
+)
+