diff options
Diffstat (limited to 'intern/SoundSystem')
40 files changed, 6986 insertions, 0 deletions
diff --git a/intern/SoundSystem/Makefile b/intern/SoundSystem/Makefile new file mode 100644 index 00000000000..e7f9760cc3c --- /dev/null +++ b/intern/SoundSystem/Makefile @@ -0,0 +1,54 @@ +# +# $Id$ +# +# ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. The Blender +# Foundation also sells licenses for use in proprietary software under +# the Blender License. See http://www.blender.org/BL/ for information +# about this. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software Foundation, +# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +# +# The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. +# All rights reserved. +# +# The Original Code is: all of this file. +# +# Contributor(s): none yet. +# +# ***** END GPL/BL DUAL LICENSE BLOCK ***** +# +# + +include nan_definitions.mk + +SOURCEDIR = source/gameengine/SoundSystem +DIR = $(OCGDIR)/SoundSystem +DIRS = intern +DIRS += dummy + +ifeq ($(OS),windows) + DIRS += fmod + DIRS += openal +endif +ifeq ($(OS),freebsd) + DIRS += openal +endif +ifeq ($(OS),$(findstring $(OS), "linux")) + ifeq ($(CPU),i386) + DIRS += openal + endif +endif + +include nan_subdirs.mk diff --git a/intern/SoundSystem/SND_C-api.h b/intern/SoundSystem/SND_C-api.h new file mode 100644 index 00000000000..9c24438c131 --- /dev/null +++ b/intern/SoundSystem/SND_C-api.h @@ -0,0 +1,356 @@ +/** + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ +#ifndef SND_BLENDER_H +#define SND_BLENDER_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "SoundDefines.h" + +#define SND_DECLARE_HANDLE(name) typedef struct name##__ { int unused; } *name + +SND_DECLARE_HANDLE(SND_AudioDeviceInterfaceHandle); +SND_DECLARE_HANDLE(SND_SceneHandle); +SND_DECLARE_HANDLE(SND_ObjectHandle); +SND_DECLARE_HANDLE(SND_ListenerHandle); + +/** + * set the specified type + */ +extern void SND_SetDeviceType(int device_type); + +/** + * get an audiodevice + */ +extern SND_AudioDeviceInterfaceHandle SND_GetAudioDevice(void); + +/** + * and let go of it + */ +extern void SND_ReleaseDevice(void); + +/** + * check if playback is desired + */ +extern int SND_IsPlaybackWanted(SND_SceneHandle scene); + +/** + * add memlocation to cache + */ +extern int SND_AddSample(SND_SceneHandle scene, + const char* filename, + void* memlocation, + int size); + +/** + * remove all samples + */ +extern void SND_RemoveAllSamples(SND_SceneHandle scene); + +/** + * forces the object to check its buffer, and fix it if it's wrong + */ +extern int SND_CheckBuffer(SND_SceneHandle scene, SND_ObjectHandle object); + +/** + * Creates a scene, initializes it and returns a handle to that scene. + * + * @param audiodevice: handle to the audiodevice. + */ +extern SND_SceneHandle SND_CreateScene(SND_AudioDeviceInterfaceHandle audiodevice); + +/** + * Stops all sounds, suspends the scene (so all resources will be freed) and deletes the scene. + * + * @param scene: handle to the soundscene. + */ +extern void SND_DeleteScene(SND_SceneHandle scene); + +/** + * Adds a soundobject to the scene, gets the buffer the sample is loaded into. + * + * @param scene: handle to the soundscene. + * @param object: handle to soundobject. + */ +extern void SND_AddSound(SND_SceneHandle scene, SND_ObjectHandle object); + +/** + * Removes a soundobject from the scene. + * + * @param scene: handle to the soundscene. + * @param object: handle to soundobject. + */ +extern void SND_RemoveSound(SND_SceneHandle scene, SND_ObjectHandle object); + +/** + * Removes all soundobjects from the scene. + * + * @param scene: handle to the soundscene. + */ +extern void SND_RemoveAllSounds(SND_SceneHandle scene); + +/** + * Stopss all soundobjects in the scene. + * + * @param scene: handle to the soundscene. + */ +extern void SND_StopAllSounds(SND_SceneHandle scene); + +/** + * Updates the listener, checks the status of all soundobjects, builds a list of all active + * objects, updates the active objects. + * + * @param audiodevice: handle to the audiodevice. + * @param scene: handle to the soundscene. + */ +extern void SND_Proceed(SND_AudioDeviceInterfaceHandle audiodevice, SND_SceneHandle scene); + +/** + * Returns a handle to the listener. + * + * @param scene: handle to the soundscene. + */ +extern SND_ListenerHandle SND_GetListener(SND_SceneHandle scene); + +/** + * Sets the gain of the listener. + * + * @param scene: handle to the soundscene. + * @param gain: factor the gain gets multiplied with. + */ +extern void SND_SetListenerGain(SND_SceneHandle scene, double gain); + +/** + * Sets a scaling to exaggerate or deemphasize the Doppler (pitch) shift resulting from the + * calculation. + * @attention $f' = dopplerfactor * f * frac{dopplervelocity - listener_velocity}{dopplervelocity + object_velocity}$ + * @attention f: frequency in sample (soundobject) + * @attention f': effective Doppler shifted frequency + * + * @param object: handle to soundobject. + * @param dopplerfactor: the dopplerfactor. + */ +extern void SND_SetDopplerFactor(SND_SceneHandle scene, double dopplerfactor); + +/** + * Sets the value of the propagation speed relative to which the source velocities are interpreted. + * @attention $f' = dopplerfactor * f * frac{dopplervelocity - listener_velocity}{dopplervelocity + object_velocity}$ + * @attention f: frequency in sample (soundobject) + * @attention f': effective Doppler shifted frequency + * + * @param object: handle to soundobject. + * @param dopplervelocity: the dopplervelocity. + */ +extern void SND_SetDopplerVelocity(SND_SceneHandle scene, double dopplervelocity); + +/** + * Creates a new soundobject and returns a handle to it. + */ +extern SND_ObjectHandle SND_CreateSound(void); + +/** + * Deletes a soundobject. + * + * @param object: handle to soundobject. + */ +extern void SND_DeleteSound(SND_ObjectHandle object); + +/** + * Sets a soundobject to SND_MUST_PLAY, so with the next proceed it will be updated and played. + * + * @param object: handle to soundobject. + */ +extern void SND_StartSound(SND_SceneHandle scene, SND_ObjectHandle object); + +/** + * Sets a soundobject to SND_MUST_STOP, so with the next proceed it will be stopped. + * + * @param object: handle to soundobject. + */ +extern void SND_StopSound(SND_SceneHandle scene, SND_ObjectHandle object); + +/** + * Sets a soundobject to SND_MUST_PAUSE, so with the next proceed it will be paused. + * + * @param object: handle to soundobject. + */ +extern void SND_PauseSound(SND_SceneHandle scene, SND_ObjectHandle object); + +/** + * Sets the name of the sample to reference the soundobject to it. + * + * @param object: handle to soundobject. + * @param samplename: the name of the sample + */ +extern void SND_SetSampleName(SND_ObjectHandle object, char* samplename); + +/** + * Sets the gain of a soundobject. + * + * @param object: handle to soundobject. + * @param gain: factor the gain gets multiplied with. + */ +extern void SND_SetGain(SND_ObjectHandle object, double gain); + +/** + * Sets the minimum gain of a soundobject. + * + * @param object: handle to soundobject. + * @param minimumgain: lower threshold for the gain. + */ +extern void SND_SetMinimumGain(SND_ObjectHandle object, double minimumgain); + +/** + * Sets the maximum gain of a soundobject. + * + * @param object: handle to soundobject. + * @param maximumgain: upper threshold for the gain. + */ +extern void SND_SetMaximumGain(SND_ObjectHandle object, double maximumgain); + +/** + * Sets the rollofffactor. The rollofffactor is a per-Source parameter the application + * can use to increase or decrease the range of a source by decreasing or increasing the + * attenuation, respectively. The default value is 1. The implementation is free to optimize + * for a rollofffactor value of 0, which indicates that the application does not wish any + * distance attenuation on the respective Source. + * + * @param object: handle to soundobject. + * @param rollofffactor: the rollofffactor. + */ +extern void SND_SetRollOffFactor(SND_ObjectHandle object, double rollofffactor); + +/** + * Sets the referencedistance at which the listener will experience gain. + * @attention G_dB = gain - 20 * log10(1 + rollofffactor * (dist - referencedistance)/referencedistance); + * + * @param object: handle to soundobject. + * @param distance: the reference distance. + */ +extern void SND_SetReferenceDistance(SND_ObjectHandle object, double referencedistance); + +/** + * Sets the pitch of a soundobject. + * + * @param object: handle to soundobject. + * @param pitch: pitchingfactor: 2.0 for doubling the frequency, 0.5 for half the frequency. + */ +extern void SND_SetPitch(SND_ObjectHandle object, double pitch); + +/** + * Sets the position a soundobject. + * + * @param object: handle to soundobject. + * @param position: position[3]. + */ +extern void SND_SetPosition(SND_ObjectHandle object, double* position); + +/** + * Sets the velocity of a soundobject. + * + * @param object: handle to soundobject. + * @param velocity: velocity[3]. + */ +extern void SND_SetVelocity(SND_ObjectHandle object, double* velocity); + +/** + * Sets the orientation of a soundobject. + * + * @param object: handle to soundobject. + * @param orientation: orientation[9]. + */ +extern void SND_SetOrientation(SND_ObjectHandle object, double* orientation); + +/** + * Sets the loopmode of a soundobject. + * + * @param object: handle to soundobject. + * @param loopmode type of the loop (SND_LOOP_OFF, SND_LOOP_NORMAL, SND_LOOP_BIDIRECTIONAL); + */ +extern void SND_SetLoopMode(SND_ObjectHandle object, int loopmode); + +/** + * Sets the looppoints of a soundobject. + * + * @param object: handle to soundobject. + * @param loopstart startpoint of the loop + * @param loopend endpoint of the loop + */ +extern void SND_SetLoopPoints(SND_ObjectHandle object, unsigned int loopstart, unsigned int loopend); + +/** + * Gets the gain of a soundobject. + * + * @param object: handle to soundobject. + */ +extern float SND_GetGain(SND_ObjectHandle object); + +/** + * Gets the pitch of a soundobject. + * + * @param object: handle to soundobject. + */ +extern float SND_GetPitch(SND_ObjectHandle object); + +/** + * Gets the looping of a soundobject. + * 0: SND_LOOP_OFF + * 1: SND_LOOP_NORMAL + * 2: SND_LOOP_BIDIRECTIONAL + * + * @param object: handle to soundobject. + */ +extern int SND_GetLoopMode(SND_ObjectHandle object); + +/** + * Gets the playstate of a soundobject. + * SND_UNKNOWN = -1 + * SND_INITIAL + * SND_MUST_PLAY + * SND_PLAYING + * SND_MUST_STOP + * SND_STOPPED + * SND_MUST_PAUSE + * SND_PAUSED + * SND_MUST_BE_DELETED + * + * @param object: handle to soundobject. + */ +extern int SND_GetPlaystate(SND_ObjectHandle object); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/intern/SoundSystem/SND_CDObject.h b/intern/SoundSystem/SND_CDObject.h new file mode 100644 index 00000000000..59817d72485 --- /dev/null +++ b/intern/SoundSystem/SND_CDObject.h @@ -0,0 +1,84 @@ +/* + * SND_CDObject.h + * + * Implementation for CD playback + * + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#ifndef __SND_CDOBJECT_H +#define __SND_CDOBJECT_H + +#include "SND_Object.h" + +class SND_CDObject : public SND_Object +{ +private: + + /** + * Private to enforce singleton + */ + SND_CDObject(); + SND_CDObject(const SND_CDObject&); + + static SND_CDObject* m_instance; + MT_Scalar m_gain; /* the gain of the object */ + int m_playmode; /* the way CD is played back (all, random, track, trackloop) */ + int m_track; /* the track for 'track' and 'trackloop' */ + int m_playstate; /* flag for current state of object */ + bool m_modified; + bool m_used; /* flag for checking if we used the cd, if not don't + call the stop cd at the end */ + +public: + static bool CreateSystem(); + static bool DisposeSystem(); + static SND_CDObject* Instance(); + + ~SND_CDObject(); + + void SetGain(MT_Scalar gain); + void SetPlaymode(int playmode); + void SetTrack(int track); + void SetPlaystate(int playstate); + void SetModified(bool modified); + void SetUsed(); + bool GetUsed(); + + bool IsModified() const; + + int GetTrack() const; + MT_Scalar GetGain() const; + int GetPlaymode() const; + int GetPlaystate() const; + +}; +#endif //__SND_CDOBJECT_H diff --git a/intern/SoundSystem/SND_DependKludge.h b/intern/SoundSystem/SND_DependKludge.h new file mode 100644 index 00000000000..b1272725f9e --- /dev/null +++ b/intern/SoundSystem/SND_DependKludge.h @@ -0,0 +1,56 @@ +/* + * SND_DependKludge.h + * + * who needs what? + * + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + + +#if defined (_WIN32) +#define USE_FMOD +#else +# if defined (__linux__) +# if defined (__i386__) +# define USE_OPENAL +# endif +# else +# if defined (__FreeBSD__) +# define USE_OPENAL +# endif +# ifdef USE_OPENAL +# undef USE_OPENAL +# endif +# ifdef USE_FMOD +# undef USE_FMOD +# endif +# endif +#endif diff --git a/intern/SoundSystem/SND_DeviceManager.h b/intern/SoundSystem/SND_DeviceManager.h new file mode 100644 index 00000000000..7e643779cfe --- /dev/null +++ b/intern/SoundSystem/SND_DeviceManager.h @@ -0,0 +1,91 @@ +/* + * SND_DeviceManager.h + * + * singleton for creating, switching and deleting audiodevices + * + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#ifndef __SND_DEVICEMANAGER_H +#define __SND_DEVICEMANAGER_H + +#include "SND_IAudioDevice.h" + +class SND_DeviceManager +{ +public : + + /** + * a subscription is needed before instances are given away + * applications must call subscribe first, get an instance, and + * when they are finished with sound, unsubscribe + */ + static void Subscribe(); + static void Unsubscribe(); + + static SND_IAudioDevice* Instance(); + static void SetDeviceType(int device_type); + +private : + + /** + * Private to enforce singleton + */ + SND_DeviceManager(); + SND_DeviceManager(const SND_DeviceManager&); + ~SND_DeviceManager(); + + static SND_IAudioDevice* m_instance; + + /** + * The type of device to be created on a call + * to Instance(). + */ + static int m_device_type; + + /** + * Remember the number of subscriptions. + * if 0, delete the device + */ + static int m_subscriptions;; +}; + +#endif //__SND_DEVICEMANAGER_H + + + + + + + + + +
\ No newline at end of file diff --git a/intern/SoundSystem/SND_IAudioDevice.h b/intern/SoundSystem/SND_IAudioDevice.h new file mode 100644 index 00000000000..6bcc8f0c072 --- /dev/null +++ b/intern/SoundSystem/SND_IAudioDevice.h @@ -0,0 +1,346 @@ +/** + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ +#ifndef SND_IAUDIODEVICE +#define SND_IAUDIODEVICE + +#include "SND_SoundObject.h" +#include "SND_CDObject.h" +#include "SND_WaveCache.h" +#include "SND_WaveSlot.h" +#include "MT_Matrix3x3.h" + + +class SND_IAudioDevice +{ +public: + + /** + * constructor + */ + SND_IAudioDevice() {}; + + /** + * destructor + */ + virtual ~SND_IAudioDevice() {}; + + /** + * check to see if initialization was successfull + * + * @return indication of succes + */ + virtual bool IsInitialized()=0; + + /** + * get the wavecache (which does sample (un)loading) + * + * @return pointer to the wavecache + */ + virtual SND_WaveCache* GetWaveCache() const =0; + + /** + * loads a sample into the device + * + * @param samplename the name of the sample + * @param memlocation pointer where the sample is stored + * @param size size of the sample in memory + * + * @return pointer to the slot with sample data + */ + virtual SND_WaveSlot* LoadSample(const STR_String& samplename, + void* memlocation, + int size)=0; + + /** + * remove a sample from the wavecache + * + * @param filename pointer to filename + */ +// virtual void RemoveSample(const char* filename)=0; + + /** + * remove all samples from the wavecache + */ + virtual void RemoveAllSamples()=0; + + /** + * get a new id from the device + * + * @param pObject pointer to soundobject + * + * @return indication of success + */ + virtual bool GetNewId(SND_SoundObject* pObject)=0; + + /** + * clear an id + * + * @param pObject pointer to soundobject + */ + virtual void ClearId(SND_SoundObject* pObject)=0; + + /** + * initialize the listener + */ + virtual void InitListener()=0; + + /** + * set the value of the propagation speed relative to which the + * source velocities are interpreted. + * f' = DOPPLER_FACTOR * f * (DOPPLER_VELOCITY - Vl) / (DOPPLER_VELOCITY + Vo) + * f: frequency in sample (soundobject) + * f': effective Doppler shifted frequency + * Vl: velocity listener + * Vo: velocity soundobject + * + * @param dopplervelocity scaling factor for doppler effect + */ + virtual void SetDopplerVelocity(MT_Scalar dopplervelocity) const =0; + + /** + * set a scaling to exaggerate or deemphasize the Doppler (pitch) + * shift resulting from the calculation. + * f' = DOPPLER_FACTOR * f * (DOPPLER_VELOCITY - Listener_velocity )/(DOPPLER_VELOCITY + object_velocity ) + * + * @param dopplerfactor scaling factor for doppler effect + */ + virtual void SetDopplerFactor(MT_Scalar dopplerfactor) const =0; + + /** + * set the roll-off factor + * + * @param rollofffactor a global volume scaling factor + */ + virtual void SetListenerRollOffFactor(MT_Scalar rollofffactor) const =0; + + /** + * make the context the current one + */ + virtual void MakeCurrent() const =0; + + /** + * update the device + */ + virtual void NextFrame() const =0; + + /** + * set the volume of the listener. + * + * @param gain the mastergain + */ + virtual void SetListenerGain(float gain) const =0; + + /** + * connect the buffer with the source + * + * @param id the id of the object + * @param buffer the buffer the sample is stored in + */ + virtual void SetObjectBuffer(int id, unsigned int buffer)=0; + + /** + * pause playback of the cd + * @param id the id of the object + * + * @return the state the object is in + */ + virtual int GetPlayState(int id) =0; + + /** + * play a sound belonging to an object. + * + * @param id the id of the object + */ + virtual void PlayObject(int id) =0; + + /** + * stop a sound belonging to an object. + * + * @param id the id of the object + */ + virtual void StopObject(int id) const =0; + + /** + * stop all sounds. + */ + virtual void StopAllObjects()=0; + + /** + * pause the sound belonging to an object. + * + * @param id the id of the object + */ + virtual void PauseObject(int id) const =0; + + /** + * set the sound to looping or non-looping. + * + * @param id the id of the object + * @param loopmode type of looping (no loop, normal, bidirectional) + */ + virtual void SetObjectLoop(int id, unsigned int loopmode) const =0; + + /** + * set the looppoints of a sound + * + * @param id the id of the object + * @param loopstart the startpoint of the loop (in samples) + * @param loopend the endpoint of the loop (in samples) + */ + virtual void SetObjectLoopPoints(int id, unsigned int loopstart, unsigned int loopend) const =0; + + /** + * set the pitch of the sound. + * + * @param id the id of the object + * @param pitch the pitch + */ + virtual void SetObjectPitch(int id, MT_Scalar pitch) const =0; + + /** + * set the gain of the sound. + * + * @param id the id of the object + * @param gain the gain + */ + virtual void SetObjectGain(int id, MT_Scalar gain) const =0; + + /** + * ROLLOFF_FACTOR is per-Source parameter the application can use to increase or decrease + * the range of a source by decreasing or increasing the attenuation, respectively. The + * default value is 1. The implementation is free to optimize for a ROLLOFF_FACTOR value + * of 0, which indicates that the application does not wish any distance attenuation on + * the respective Source. + * + * @param id the id of the object + * @param rolloff a per-source volume scaling factor + */ + virtual void SetObjectRollOffFactor(int id, MT_Scalar rolloff) const =0; + + /** + * min_gain indicates the minimal gain which is always guaranteed for this sound + * + * @param id the id of the object + * @param mingain the minimum gain of the object + */ + virtual void SetObjectMinGain(int id, MT_Scalar mingain) const =0; + + /** + * max_gain indicates the maximal gain which is always guaranteed for this sound + * + * @param id the id of the object + * @param maxgain the maximum gain of the object + */ + virtual void SetObjectMaxGain(int id, MT_Scalar maxgain) const =0; + /** + * set the distance at which the Listener will experience gain. + * G_dB = GAIN - 20*log10(1 + ROLLOFF_FACTOR*(dist-REFERENCE_DISTANCE)/REFERENCE_DISTANCE ); + * + * @param id the id of the object + * @param referencedistance the distance at which the listener will start hearing + */ + virtual void SetObjectReferenceDistance(int id, MT_Scalar referencedistance) const =0; + + /** + * set the position, velocity and orientation of a sound. + * + * @param id the id of the object + * @param position the position of the object + * @param velocity the velocity of the object + * @param orientation the orientation of the object + * @param lisposition the position of the listener + * @param rollofffactor the rollofffactor of the object + */ + virtual void SetObjectTransform(int id, + const MT_Vector3& position, + const MT_Vector3& velocity, + const MT_Matrix3x3& orientation, + const MT_Vector3& lisposition, + const MT_Scalar& rollofffactor) const =0; + + /** + * make a sound 2D + * + * @param id the id of the object + */ + virtual void ObjectIs2D(int id) const =0; + + /** + * tell the device we want cd suppport + */ + virtual void UseCD() const =0; + + /** + * start playback of the cd + * + * @param track the tracknumber to start playback from + */ + virtual void PlayCD(int track) const =0; + + /** + * pause playback of the cd (true == pause, false == resume) + */ + virtual void PauseCD(bool pause) const =0; + + /** + * stop playback of the cd + */ + virtual void StopCD() const =0; + + /** + * set the playbackmode of the cd + * SND_CD_ALL play all tracks + * SND_CD_TRACK play one track + * SND_CD_TRACKLOOP play one track looped + * SND_CD_RANDOM play all tracks in random order + * + * @param playmode playmode + */ + virtual void SetCDPlaymode(int playmode) const =0; + + /** + * set the volume playback of the cd + * + * @param gain the gain + */ + virtual void SetCDGain(MT_Scalar gain) const =0; + + virtual void StartUsingDSP() =0; + virtual float* GetSpectrum() =0; + virtual void StopUsingDSP() =0; + +protected: + + virtual void RevokeSoundObject(SND_SoundObject* pObject)=0; +}; + +#endif //SND_IAUDIODEVICE diff --git a/intern/SoundSystem/SND_Object.h b/intern/SoundSystem/SND_Object.h new file mode 100644 index 00000000000..2ae9bcc1dd0 --- /dev/null +++ b/intern/SoundSystem/SND_Object.h @@ -0,0 +1,55 @@ +/* + * SND_Object.h + * + * Abstract sound object + * + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#ifndef __SND_OBJECT_H +#define __SND_OBJECT_H + +#include "GEN_List.h" +#include "MT_Matrix3x3.h" +#include "SoundDefines.h" + +/** + * SND_Object is an interface class for soundobjects, listeners and other + * kinds of sound related thingies. + */ + +class SND_Object : public GEN_Link +{ +public: + SND_Object() {}; + virtual ~SND_Object() {}; +}; +#endif //__SND_OBJECT_H diff --git a/intern/SoundSystem/SND_Scene.h b/intern/SoundSystem/SND_Scene.h new file mode 100644 index 00000000000..c2f6e5d8c48 --- /dev/null +++ b/intern/SoundSystem/SND_Scene.h @@ -0,0 +1,106 @@ +/* + * SND_Scene.h + * + * The scene for sounds. + * + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#ifdef WIN32 +#pragma warning (disable:4786) // get rid of stupid stl-visual compiler debug warning +#endif //WIN32 + +#ifndef __SND_SCENE_H +#define __SND_SCENE_H + +#include "SoundDefines.h" +#include "SND_SoundObject.h" +#include "SND_CDObject.h" +#include "SND_SoundListener.h" +#include "SND_WaveSlot.h" + +#include "MT_Vector3.h" +#include "MT_Matrix3x3.h" +#include "STR_String.h" + +#include <set> + + +class SND_Scene +{ + std::set<class SND_SoundObject*> m_soundobjects; + + GEN_List m_activeobjects; + class SND_IAudioDevice* m_audiodevice; + class SND_WaveCache* m_wavecache; + class SND_SoundListener m_listener; + bool m_audio; // to check if audio works + bool m_audioplayback; // to check if audioplayback is wanted + + void UpdateListener(); + void BuildActiveList(MT_Scalar curtime); + void UpdateActiveObects(); + void UpdateCD(); + +public: + SND_Scene(SND_IAudioDevice* adi); + ~SND_Scene(); + + bool IsPlaybackWanted(); + + void AddActiveObject(SND_SoundObject* pObject, MT_Scalar curtime); + void RemoveActiveObject(SND_SoundObject* pObject); + void DeleteObjectWhenFinished(SND_SoundObject* pObject); + + void Proceed(); + + int LoadSample(const STR_String& samplename, + void* memlocation, + int size); + void RemoveAllSamples(); + bool CheckBuffer(SND_SoundObject* pObject); + bool IsSampleLoaded(STR_String& samplename); + + void AddObject(SND_SoundObject* pObject); + bool SetCDObject(SND_CDObject* cdobject); + void DeleteObject(SND_SoundObject* pObject); + void RemoveAllObjects(); + void StopAllObjects(); + int GetObjectStatus(SND_SoundObject* pObject) const; + + void SetListenerTransform(const MT_Vector3& pos, + const MT_Vector3& vel, + const MT_Matrix3x3& mat); + + SND_SoundListener* GetListener(); +}; + +#endif //__SND_SCENE_H diff --git a/intern/SoundSystem/SND_SoundListener.h b/intern/SoundSystem/SND_SoundListener.h new file mode 100644 index 00000000000..63d8eb65942 --- /dev/null +++ b/intern/SoundSystem/SND_SoundListener.h @@ -0,0 +1,84 @@ +/* + * SND_SoundListener.h + * + * A SoundListener is for sound what a camera is for vision. + * + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#ifndef __SND_SOUNDLISTENER_H +#define __SND_SOUNDLISTENER_H + +#include "SND_Object.h" + + +class SND_SoundListener : public SND_Object +{ +public: + SND_SoundListener(); + virtual ~SND_SoundListener(); + + void SetStateFlag(unsigned int stateflags); + void SetGain(MT_Scalar gain); + void SetPosition(const MT_Vector3& pos); + void SetVelocity(const MT_Vector3& vel); + void SetOrientation(const MT_Matrix3x3& ori); + void SetDopplerFactor(MT_Scalar dopplerfactor); + void SetDopplerVelocity(MT_Scalar dopplervelocity); + void SetScale(MT_Scalar scale); + + void SetModified(bool modified); + bool IsModified() const; + + unsigned int GetStateFlags() const; + MT_Scalar GetGain() const; + MT_Vector3 GetPosition() const; + MT_Vector3 GetVelocity() const; + MT_Matrix3x3 GetOrientation(); + + MT_Scalar GetDopplerFactor() const; + MT_Scalar GetDopplerVelocity() const; + MT_Scalar GetScale() const; + +private: + void* m_listener; + bool m_modified; + + MT_Scalar m_gain; /* overall gain */ + MT_Vector3 m_position; /* position; left/right, up/down, in/out */ + MT_Vector3 m_velocity; /* velocity of the listener */ + MT_Matrix3x3 m_orientation; /* orientation of the listener */ + + MT_Scalar m_dopplerfactor; /* scaling factor for the Doppler (pitch) shift */ + MT_Scalar m_dopplervelocity; /* factor for the reference velocity (for Dopplereffect) */ + MT_Scalar m_scale; +}; +#endif //__SND_SOUNDLISTENER_H diff --git a/intern/SoundSystem/SND_SoundObject.h b/intern/SoundSystem/SND_SoundObject.h new file mode 100644 index 00000000000..4c47cdc27b5 --- /dev/null +++ b/intern/SoundSystem/SND_SoundObject.h @@ -0,0 +1,162 @@ +/* + * SND_SoundObject.h + * + * Implementation of the abstract sound object + * + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#ifndef __SND_SOUNDOBJECT_H +#define __SND_SOUNDOBJECT_H + +#include "SND_Object.h" +#include "STR_String.h" + + +/** + * SND_SoundObject is a class for api independent sounddata storage conected to an actuator + */ + +class SND_SoundObject : public SND_Object +{ +private: + STR_String m_samplename; /* name of the sample */ + STR_String m_objectname; /* name of the object */ + unsigned int m_buffer; + + bool m_active; /* is the object active or not? */ + int m_id; + MT_Scalar m_lifespan; /* the lifespan of the sound seconds */ + MT_Scalar m_timestamp; + + MT_Scalar m_length; /* length of the sample in seconds */ + + MT_Scalar m_gain; /* the gain of the object */ + MT_Scalar m_rollofffactor; /* the scaling factor to increase or decrease the range + of a source by decreasing or increasing the + attenuation, respectively */ + MT_Scalar m_referencedistance;/* the distance at which the listener will experience + gain */ + MT_Scalar m_mingain; /* indicates the minimal gain which is always guaranteed + for this source */ + MT_Scalar m_maxgain; /* indicates the maximal gain which is always guaranteed + for this source */ + + MT_Scalar m_pitch; /* the pitch of the object */ + MT_Vector3 m_position; /* position; left/right, up/down, in/out */ + MT_Vector3 m_velocity; /* velocity of the object */ + MT_Matrix3x3 m_orientation; /* orientation of the object */ + unsigned int m_loopmode; /* loop normal or bidirectional? */ + unsigned int m_loopstart; /* start of looppoint in samples! */ + unsigned int m_loopend; /* end of looppoint in samples! */ + bool m_is3d; /* is the object 3D or 2D? */ + int m_playstate; /* flag for current state of object */ + bool m_modified; + unsigned int m_running; + bool m_highpriority; /* may the sound be ditched when we run out of voices? */ + +public: + + SND_SoundObject(); + ~SND_SoundObject(); + + void SetBuffer(unsigned int buffer); + void SetActive(bool active); + + void StartSound(); + void StopSound(); + void PauseSound(); + void DeleteWhenFinished(); + + void SetObjectName(STR_String objectname); + void SetSampleName(STR_String samplename); + void SetLength(MT_Scalar length); + + void SetPitch(MT_Scalar pitch); + void SetGain(MT_Scalar gain); + void SetMinGain(MT_Scalar mingain); + void SetMaxGain(MT_Scalar maxgain); + void SetRollOffFactor(MT_Scalar rollofffactor); + void SetReferenceDistance(MT_Scalar distance); + void SetPosition(const MT_Vector3& pos); + void SetVelocity(const MT_Vector3& vel); + void SetOrientation(const MT_Matrix3x3& orient); + void SetLoopMode(unsigned int loopmode); + void SetLoopStart(unsigned int loopstart); + void SetLoopEnd(unsigned int loopend); + void Set3D(bool threedee); + void SetPlaystate(int playstate); + void SetHighPriority(bool priority); + + void SetId(int id); + void SetLifeSpan(); + void SetTimeStamp(MT_Scalar timestamp); + + void SetModified(bool modified); + + bool IsLifeSpanOver(MT_Scalar curtime) const; + bool IsActive() const; + bool IsModified() const; + bool IsHighPriority() const; + + void InitRunning(); + bool IsRunning() const; + void AddRunning(); + + int GetId() const; + MT_Scalar GetLifeSpan() const; + MT_Scalar GetTimestamp() const; + + unsigned int GetBuffer(); + const STR_String& GetSampleName(); + const STR_String& GetObjectName(); + + MT_Scalar GetLength() const; + MT_Scalar GetGain() const; + MT_Scalar GetPitch() const; + + MT_Scalar GetMinGain() const; + MT_Scalar GetMaxGain() const; + MT_Scalar GetRollOffFactor() const; + MT_Scalar GetReferenceDistance() const; + + MT_Vector3 GetPosition() const; + MT_Vector3 GetVelocity() const; + MT_Matrix3x3 GetOrientation() const; + unsigned int GetLoopMode() const; + unsigned int GetLoopStart() const; + unsigned int GetLoopEnd() const; + bool Is3D() const; + int GetPlaystate() const; + +}; +#endif //__SND_SOUNDOBJECT_H + diff --git a/intern/SoundSystem/SND_Utils.h b/intern/SoundSystem/SND_Utils.h new file mode 100644 index 00000000000..c9c3774b180 --- /dev/null +++ b/intern/SoundSystem/SND_Utils.h @@ -0,0 +1,113 @@ +/** + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ +#ifndef SND_UTILS_H +#define SND_UTILS_H + +#include "SND_WaveSlot.h" + +#ifdef __cplusplus +extern "C" +{ +#endif + +typedef struct +{ + unsigned char riff[4]; + signed int size; + unsigned char type[4]; +} WavFileHeader; + +typedef struct +{ + unsigned short format; + unsigned short numberofchannels; + unsigned int samplerate; + unsigned int bytespersec; + unsigned short blockalignment; + unsigned short bitrate; +} WavFmtHeader; + +typedef struct +{ + unsigned short size; + unsigned short samplesperblock; +} WavFmtExHeader; + +typedef struct +{ + unsigned int Manufacturer; + unsigned int Product; + unsigned int SamplePeriod; + unsigned int Note; + unsigned int FineTune; + unsigned int SMPTEFormat; + unsigned int SMPTEOffest; + unsigned int loops; + unsigned int SamplerData; + struct + { + unsigned int Identifier; + unsigned int Type; + unsigned int Start; + unsigned int End; + unsigned int Fraction; + unsigned int Count; + } Loop[1]; +} WavSampleHeader; + +typedef struct +{ + unsigned char id[4]; + unsigned int size; +} WavChunkHeader; + +/** + * loads a sample and returns a pointer + */ +extern void* SND_LoadSample(char *filename); + +extern bool SND_IsSampleValid(const STR_String& name, void* memlocation); +extern unsigned int SND_GetSampleFormat(void* sample); +extern unsigned int SND_GetNumberOfChannels(void* sample); +extern unsigned int SND_GetSampleRate(void* sample); +extern unsigned int SND_GetBitRate(void* sample); +extern unsigned int SND_GetNumberOfSamples(void* sample); +extern unsigned int SND_GetHeaderSize(void* sample); +extern unsigned int SND_GetExtraChunk(void* sample); + +extern void SND_GetSampleInfo(signed char* sample, SND_WaveSlot* waveslot); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/intern/SoundSystem/SND_WaveCache.h b/intern/SoundSystem/SND_WaveCache.h new file mode 100644 index 00000000000..5618b8b9ecf --- /dev/null +++ b/intern/SoundSystem/SND_WaveCache.h @@ -0,0 +1,68 @@ +/* + * SND_WaveCache.h + * + * abstract wavecache, a way to organize samples + * + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#ifdef WIN32 +#pragma warning (disable:4786) // get rid of stupid stl-visual compiler debug warning +#endif //WIN32 + +#ifndef __SND_WAVECACHE_H +#define __SND_WAVECACHE_H + +#include "SND_WaveSlot.h" +#include "SoundDefines.h" +#include "SND_SoundObject.h" +#include <map> + +class SND_WaveCache +{ +public: + SND_WaveCache(); + virtual ~SND_WaveCache(); + + SND_WaveSlot* GetWaveSlot(const STR_String& samplename); + + void RemoveAllSamples(); + void RemoveSample(const STR_String& samplename, int buffer); + +private: + std::map<STR_String, SND_WaveSlot*> m_samplecache; + + SND_WaveSlot* m_bufferList[NUM_BUFFERS]; + + void FreeSamples(); +}; + +#endif //__SND_WAVECACHE_H diff --git a/intern/SoundSystem/SND_WaveSlot.h b/intern/SoundSystem/SND_WaveSlot.h new file mode 100644 index 00000000000..3d1e0d98ae9 --- /dev/null +++ b/intern/SoundSystem/SND_WaveSlot.h @@ -0,0 +1,94 @@ +/* + * SND_WaveSlot.cpp + * + * class for storing sample related information + * + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#ifndef __SND_WAVESLOT_H +#define __SND_WAVESLOT_H + +#include "STR_String.h" + +class SND_WaveSlot +{ + STR_String m_samplename; + bool m_loaded; + void* m_data; + unsigned int m_buffer; + unsigned int m_sampleformat; + unsigned int m_numberofchannels; + unsigned int m_samplerate; + unsigned int m_bitrate; + unsigned int m_numberofsamples; + unsigned int m_filesize; + +public: + + SND_WaveSlot(): m_loaded(false), + m_data(NULL), + m_buffer(0), + m_sampleformat(0), + m_numberofchannels(0), + m_samplerate(0), + m_bitrate(0), + m_numberofsamples(0), + m_filesize(0) + {}; + ~SND_WaveSlot(); + + void SetSampleName(STR_String samplename); + void SetLoaded(bool loaded); + void SetData(void* data); + void SetBuffer(unsigned int buffer); + void SetSampleFormat(unsigned int sampleformat); + void SetNumberOfChannels(unsigned int numberofchannels); + void SetSampleRate(unsigned int samplerate); + void SetBitRate(unsigned int bitrate); + void SetNumberOfSamples(unsigned int numberofsamples); + void SetFileSize(unsigned int filesize); + + + const STR_String& GetSampleName(); + bool IsLoaded() const; + void* GetData(); + unsigned int GetBuffer() const; + unsigned int GetSampleFormat() const; + unsigned int GetNumberOfChannels() const; + unsigned int GetSampleRate() const; + unsigned int GetBitRate() const; + unsigned int GetNumberOfSamples() const; + unsigned int GetFileSize() const; + +}; + +#endif //__SND_WAVESLOT_H diff --git a/intern/SoundSystem/SND_test/Makefile b/intern/SoundSystem/SND_test/Makefile new file mode 100644 index 00000000000..0aae4866f1c --- /dev/null +++ b/intern/SoundSystem/SND_test/Makefile @@ -0,0 +1,53 @@ +# +# $Id$ +# +# ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. The Blender +# Foundation also sells licenses for use in proprietary software under +# the Blender License. See http://www.blender.org/BL/ for information +# about this. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software Foundation, +# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +# +# The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. +# All rights reserved. +# +# The Original Code is: all of this file. +# +# Contributor(s): none yet. +# +# ***** END GPL/BL DUAL LICENSE BLOCK ***** +# +# + +LIBNAME = SoundSystem +DIR = $(OCGDIR)/gameengine/$(LIBNAME) +ALLTARGETS = $(OBJS) $(DIR)/$(DEBUG_DIR)SoundSystem + +include nan_compile.mk + +CPPFLAGS += $(NAN_LEVEL_1_WARNINGS) + +CPPFLAGS += -I$(NAN_MOTO)/include +CPPFLAGS += -I../../../kernel/gen_system +CPPFLAGS += -I.. -I../SND_BlenderWaveCache -I../SND_OpenAL + +TESTLIB = $(OCGDIR)/gameengine/OpenALSoundSystem/$(DEBUG_DIR)libOpenALSoundSystem.a +TESTLIB += $(OCGDIR)/gameengine/BlenderWaveCache/$(DEBUG_DIR)libBlenderWaveCache.a +TESTLIB += $(OCGDIR)/kernel/gen_system/$(DEBUG_DIR)libgen_system.a +TESTLIB += $(OCGDIR)/gameengine/SoundSystem/$(DEBUG_DIR)libSoundSystem.a +TESTLIB += $(NAN_OPENAL)/lib/libopenal.a + +$(DIR)/$(DEBUG_DIR)SoundSystem: $(OBJS) $(TESTLIB) + $(CC) $(LDFLAGS) -o $@ $(OBJS) $(TESTLIB) -lm -pthread -ldl -lstdc++ diff --git a/intern/SoundSystem/SND_test/SND_test.c b/intern/SoundSystem/SND_test/SND_test.c new file mode 100644 index 00000000000..eff52aef61e --- /dev/null +++ b/intern/SoundSystem/SND_test/SND_test.c @@ -0,0 +1,152 @@ +/* SND_test.c nov 2000 +* +* testfile for the SND module +* +* janco verduin +* +* $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** +*/ + +#include "SND_C-api.h" +#include "BlenderWaveCacheCApi.h" +#include "OpenALC-Api.h" +#include <stdio.h> +#include <stdlib.h> +#if defined(WIN32) +#include <io.h> +#else +#include <unistd.h> +#endif +#include <fcntl.h> + +static int buf[3]; + +float oPos[3]={3.0, 0.0,-1.0}; +float oVel[3]={0.0, 0.0, 1.0}; +float oOri[6]={0.0, 0.0, 1.0, 0.0, 1.0, 0.0}; + +void* ReadFile(char *filename) +{ + int file, filelen; + void *data = NULL; + +#if defined(WIN32) + file = open(filename, O_BINARY|O_RDONLY); +#else + file = open(filename, 0|O_RDONLY); +#endif + + if (file == -1) { + printf("can't open file.\n"); + printf("press q for quit.\n"); + + } + else { + filelen = lseek(file, 0, SEEK_END); + lseek(file, 0, SEEK_SET); + + if (filelen != 0){ + data = malloc(filelen); + if (read(file, data, filelen) != filelen) { + free(data); + data = NULL; + } + } + close(file); + + } + return (data); +} + +int main(int argc, char* argv[]) +{ + int ch; + char* samplename = NULL; + void* sampleinmemory = NULL; + SND_CacheHandle wavecache = NULL; + SND_SceneHandle scene = NULL; + SND_ObjectHandle object = NULL; + + wavecache = SND_GetWaveCache(); + scene = SND_CreateOpenALScene(wavecache); + + samplename = "2.wav"; + sampleinmemory = ReadFile(samplename); + + if (sampleinmemory) { + + object = SND_CreateObject(); + SND_AddMemoryLocation(samplename, sampleinmemory); + SND_SetSampleName(object, samplename); + SND_AddObject(scene, object); + printf("go your gang...\n"); + printf("1: play\n"); + printf("2: stop\n"); + printf("q: quit\n"); + } + do + { + ch = getchar(); + ch = toupper(ch); + switch (ch) + { + case '1': + { + SND_SetPitch(object, 1.0); + SND_SetGain(object, 1.0); + SND_StartSound(object); + break; + } + case '2': + { + SND_StopSound(object); + break; + } + default: + break; + } + + SND_Proceed(scene); + + } while (ch != 'Q'); + + if (object) { + + SND_RemoveObject(scene, object); + SND_DeleteObject(object); + } + + SND_DeleteScene(scene); + SND_DeleteCache(); + + return 0; + +} diff --git a/intern/SoundSystem/SoundDefines.h b/intern/SoundSystem/SoundDefines.h new file mode 100644 index 00000000000..b2c00b0ade0 --- /dev/null +++ b/intern/SoundSystem/SoundDefines.h @@ -0,0 +1,119 @@ +/* + * SoundDefines.h + * + * this is where all kinds of defines are stored + * + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#ifndef __SOUNDDEFINES_H +#define __SOUNDDEFINES_H + +/* the types of devices */ +enum +{ + snd_e_dummydevice = 0, + snd_e_fmoddevice, + snd_e_openaldevice +}; + +/* general stuff */ +#define NUM_BUFFERS 128 +#define NUM_SOURCES 16 + +/* openal related stuff */ +#define AL_LOOPING 0x1007 + +/* fmod related stuff */ +#ifdef WIN32 +#define MIXRATE 22050 +#else +#define MIXRATE 44100 +#endif +#define NUM_FMOD_MIN_HW_CHANNELS 16 +#define NUM_FMOD_MAX_HW_CHANNELS 16 + +/* activelist defines */ +enum +{ + SND_REMOVE_ACTIVE_OBJECT = 0, + SND_ADD_ACTIVE_OBJECT, + SND_DO_NOTHING +}; + +/* playstate flags */ +enum +{ + SND_UNKNOWN = -1, + SND_INITIAL, + SND_MUST_PLAY, + SND_PLAYING, + SND_MUST_STOP, + SND_STOPPED, + SND_MUST_PAUSE, + SND_PAUSED, + SND_MUST_RESUME, + SND_MUST_STOP_WHEN_FINISHED, + SND_MUST_BE_DELETED +}; + +/* loopmodes */ +enum +{ + SND_LOOP_OFF = 0, + SND_LOOP_NORMAL, + SND_LOOP_BIDIRECTIONAL +}; + + +/* cd playstate flags */ +enum +{ + SND_CD_ALL = 0, + SND_CD_TRACK, + SND_CD_TRACKLOOP +}; + +/* sample types */ +enum +{ + SND_WAVE_FORMAT_UNKNOWN = 0, + SND_WAVE_FORMAT_PCM, + SND_WAVE_FORMAT_ADPCM, + SND_WAVE_FORMAT_ALAW = 6, + SND_WAVE_FORMAT_MULAW, + SND_WAVE_FORMAT_DIALOGIC_OKI_ADPCM = 17, + SND_WAVE_FORMAT_CONTROL_RES_VQLPC = 34, + SND_WAVE_FORMAT_GSM_610 = 49, + SND_WAVE_FORMAT_MPEG3 = 85 +}; + +#endif //__SOUNDDEFINES_H diff --git a/intern/SoundSystem/dummy/Makefile b/intern/SoundSystem/dummy/Makefile new file mode 100644 index 00000000000..fd2c85e7464 --- /dev/null +++ b/intern/SoundSystem/dummy/Makefile @@ -0,0 +1,46 @@ +# +# $Id$ +# +# ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. The Blender +# Foundation also sells licenses for use in proprietary software under +# the Blender License. See http://www.blender.org/BL/ for information +# about this. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software Foundation, +# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +# +# The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. +# All rights reserved. +# +# The Original Code is: all of this file. +# +# Contributor(s): none yet. +# +# ***** END GPL/BL DUAL LICENSE BLOCK ***** +# +# + +LIBNAME = DummySoundSystem +DIR = $(OCGDIR)/gameengine/$(LIBNAME) + +include nan_compile.mk + +CCFLAGS += $(LEVEL_1_CPP_WARNINGS) + +CPPFLAGS += -I$(NAN_STRING)/include +CPPFLAGS += -I$(NAN_MOTO)/include +CPPFLAGS += -I../../../../kernel/gen_system +CPPFLAGS += -I../intern +CPPFLAGS += -I.. +CPPFLAGS += -I. diff --git a/intern/SoundSystem/dummy/SND_DummyDevice.cpp b/intern/SoundSystem/dummy/SND_DummyDevice.cpp new file mode 100644 index 00000000000..4d1f69c6f33 --- /dev/null +++ b/intern/SoundSystem/dummy/SND_DummyDevice.cpp @@ -0,0 +1,53 @@ +/* + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + * SND_FmodDevice derived from SND_IAudioDevice + */ + +#ifdef WIN32 +#pragma warning (disable:4786) // get rid of stupid stl-visual compiler debug warning +#endif //WIN32 + +#include "SND_DummyDevice.h" + +SND_DummyDevice::SND_DummyDevice() +{ +} + + + +SND_DummyDevice::~SND_DummyDevice() +{ +#ifdef ONTKEVER + printf("SND_DummyDevice destructor"); +#endif +} + + diff --git a/intern/SoundSystem/dummy/SND_DummyDevice.h b/intern/SoundSystem/dummy/SND_DummyDevice.h new file mode 100644 index 00000000000..717a34550bc --- /dev/null +++ b/intern/SoundSystem/dummy/SND_DummyDevice.h @@ -0,0 +1,95 @@ +/** + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ +#ifndef SND_DUMMYDEVICE +#define SND_DUMMYDEVICE + +#include "SND_AudioDevice.h" + +class SND_DummyDevice : public SND_AudioDevice +{ +public: + SND_DummyDevice(); + ~SND_DummyDevice(); + + bool Init() { return false; } + + SND_WaveSlot* LoadSample(const STR_String& samplename, + void* memlocation, + int size) { return NULL; } + + void InitListener() {}; + void SetListenerGain(float gain) const {}; + void SetDopplerVelocity(MT_Scalar dopplervelocity) const {}; + void SetDopplerFactor(MT_Scalar dopplerfactor) const {}; + void SetListenerRollOffFactor(MT_Scalar rollofffactor) const {}; + + void MakeCurrent() const {}; + + void NextFrame() const {}; + + void SetObjectBuffer(int id, unsigned int buffer) {}; + + int GetPlayState(int id) { return SND_UNKNOWN; } + void PlayObject(int id) {}; + void StopObject(int id) const {}; + void StopAllObjects() {}; + void PauseObject(int id) const {}; + + void SetObjectLoop(int id, unsigned int loopmode) const {}; + void SetObjectLoopPoints(int id, unsigned int loopstart, unsigned int loopend) const {}; + void SetObjectPitch(int id, MT_Scalar pitch) const {}; + void SetObjectGain(int id, MT_Scalar gain) const {}; + void SetObjectMinGain(int id, MT_Scalar mingain) const {}; + void SetObjectMaxGain(int id, MT_Scalar maxgain) const {}; + void SetObjectRollOffFactor(int id, MT_Scalar rolloff) const {}; + void SetObjectReferenceDistance(int id, MT_Scalar distance) const {}; + + void SetObjectTransform(int id, + const MT_Vector3& position, + const MT_Vector3& velocity, + const MT_Matrix3x3& orientation, + const MT_Vector3& lisposition, + const MT_Scalar& rollofffactor) const {}; + void ObjectIs2D(int id) const {}; + + void PlayCD(int track) const {}; + void PauseCD(bool pause) const {}; + void StopCD() const {}; + void SetCDPlaymode(int playmode) const {}; + void SetCDGain(MT_Scalar gain) const {}; + + void StartUsingDSP() {}; + float* GetSpectrum() { return NULL; } + void StopUsingDSP() {}; +}; + +#endif //SND_DUMMYDEVICE diff --git a/intern/SoundSystem/fmod/Makefile b/intern/SoundSystem/fmod/Makefile new file mode 100644 index 00000000000..bb545c36e2d --- /dev/null +++ b/intern/SoundSystem/fmod/Makefile @@ -0,0 +1,47 @@ +# +# $Id$ +# +# ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. The Blender +# Foundation also sells licenses for use in proprietary software under +# the Blender License. See http://www.blender.org/BL/ for information +# about this. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software Foundation, +# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +# +# The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. +# All rights reserved. +# +# The Original Code is: all of this file. +# +# Contributor(s): none yet. +# +# ***** END GPL/BL DUAL LICENSE BLOCK ***** +# +# + +LIBNAME = FmodSoundSystem +DIR = $(OCGDIR)/gameengine/$(LIBNAME) + +include nan_compile.mk + +CCFLAGS += $(LEVEL_1_CPP_WARNINGS) + +CPPFLAGS += -I$(NAN_FMOD)/include +CPPFLAGS += -I$(NAN_STRING)/include +CPPFLAGS += -I$(NAN_MOTO)/include +CPPFLAGS += -I../../../kernel/gen_system +CPPFLAGS += -I../intern +CPPFLAGS += -I.. +CPPFLAGS += -I. diff --git a/intern/SoundSystem/fmod/SND_FmodDevice.cpp b/intern/SoundSystem/fmod/SND_FmodDevice.cpp new file mode 100644 index 00000000000..862703d0d59 --- /dev/null +++ b/intern/SoundSystem/fmod/SND_FmodDevice.cpp @@ -0,0 +1,543 @@ +/* + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + * SND_FmodDevice derived from SND_IAudioDevice + */ + +#ifdef WIN32 +#pragma warning (disable:4786) // get rid of stupid stl-visual compiler debug warning +#endif //WIN32 + +#include "SND_FmodDevice.h" +#include "SoundDefines.h" +#include "SYS_System.h" +#include "SND_Utils.h" + +SND_FmodDevice::SND_FmodDevice() +{ + // check if audio is wanted + SYS_SystemHandle syshandle = SYS_GetSystem(); + int audio = SYS_GetCommandLineInt(syshandle,"noaudio",0); + + m_dspunit = NULL; + + if (audio == 1) + m_audio = false; + else + m_audio = true; + + // let's check if we can get fmod to initialize... + if (m_audio) + { + signed char MinHardwareChannels = FSOUND_SetMinHardwareChannels(NUM_FMOD_MIN_HW_CHANNELS); + signed char MaxHardwareChannels = FSOUND_SetMaxHardwareChannels(NUM_FMOD_MAX_HW_CHANNELS); + + if (FSOUND_Init(MIXRATE, NUM_SOURCES, 0)) + { + m_max_channels = FSOUND_GetMaxChannels(); + m_num_hardware_channels = FSOUND_GetNumHardwareChannels(); + m_num_software_channels = NUM_SOURCES; + + // let's get us a wavecache + m_wavecache = new SND_WaveCache(); + + int i; + for (i = 0; i < NUM_BUFFERS; i++) + m_buffers[i] = NULL; + + for (i = 0; i < NUM_SOURCES; i++) + { + m_sources[i] = NULL; + m_frequencies[i] = 0; + m_channels[i] = 0; + } + } + else + { + m_audio = false; + } + } + +#ifdef ONTKEVER + int numdrivers = FSOUND_GetNumDrivers(); + int output = FSOUND_GetOutput(); + int oputputrate = FSOUND_GetOutputRate(); + int mixer = FSOUND_GetMixer(); + + printf("maxchannels is: %d\n", m_max_channels); + printf("num hw channels is: %d\n", m_num_hardware_channels); + printf("num sw channels is: %d\n", m_num_software_channels); + printf("numdrivers is: %d\n", numdrivers); + printf("output is: %d\n", output); + printf("oputputrate is: %d\n", oputputrate); + printf("mixer is: %d\n", mixer); +#endif +} + + + +SND_FmodDevice::~SND_FmodDevice() +{ + // let's see if we used the cd. if not, just leave it alone + SND_CDObject* pCD = SND_CDObject::Instance(); + + if (pCD) + { + this->StopCD(); + SND_CDObject::DisposeSystem(); + } + + StopUsingDSP(); + + FSOUND_Close(); +} + + + +void SND_FmodDevice::UseCD() const +{ + // only fmod has CD support, so only create it here + SND_CDObject::CreateSystem(); +} + + + +void SND_FmodDevice::MakeCurrent() const +{ + // empty +} + + + +SND_WaveSlot* SND_FmodDevice::LoadSample(const STR_String& name, + void* memlocation, + int size) +{ + SND_WaveSlot* waveslot = NULL; + STR_String samplename = name; + + if (m_audio) + { + /* first check if the sample is supported */ + if (SND_IsSampleValid(name, memlocation)) + { + /* create the waveslot */ + waveslot = m_wavecache->GetWaveSlot(samplename); + + if (waveslot) + { + int buffer = waveslot->GetBuffer(); + + /* load the sample from memory? */ + if (size && memlocation) + { + m_buffers[buffer] = FSOUND_Sample_Load(buffer, (char*)memlocation, FSOUND_LOADMEMORY, size); + + /* if the loading succeeded, fill the waveslot with info */ + if (m_buffers[buffer]) + { + int sampleformat = SND_GetSampleFormat(memlocation); + int numberofchannels = SND_GetNumberOfChannels(memlocation); + int samplerate = SND_GetSampleRate(memlocation); + int bitrate = SND_GetBitRate(memlocation); + int numberofsamples = SND_GetNumberOfSamples(memlocation); + + waveslot->SetFileSize(size); + waveslot->SetData(memlocation); + waveslot->SetSampleFormat(sampleformat); + waveslot->SetNumberOfChannels(numberofchannels); + waveslot->SetSampleRate(samplerate); + waveslot->SetBitRate(bitrate); + waveslot->SetNumberOfSamples(numberofsamples); + } + } + /* or from file? */ + else + { + m_buffers[buffer] = FSOUND_Sample_Load(buffer, samplename.Ptr(), FSOUND_LOOP_NORMAL, NULL); + } + +#ifdef ONTKEVER + int error = FSOUND_GetError(); + printf("sample load: errornumber is: %d\n", error); +#endif + + /* if the loading succeeded, mark the waveslot */ + if (m_buffers[buffer]) + { + waveslot->SetLoaded(true); + } + /* or when it failed, free the waveslot */ + else + { + m_wavecache->RemoveSample(waveslot->GetSampleName(), waveslot->GetBuffer()); + waveslot = NULL; + } + } + } + } + + return waveslot; +} + + + + +// listener's and general stuff ////////////////////////////////////////////////////// + + + +/* sets the global dopplervelocity */ +void SND_FmodDevice::SetDopplerVelocity(MT_Scalar dopplervelocity) const +{ + /* not supported by fmod */ + FSOUND_3D_Listener_SetDopplerFactor(dopplervelocity); +} + + + +/* sets the global dopplerfactor */ +void SND_FmodDevice::SetDopplerFactor(MT_Scalar dopplerfactor) const +{ + FSOUND_3D_Listener_SetDopplerFactor(dopplerfactor); +} + + + +/* sets the global rolloff factor */ +void SND_FmodDevice::SetListenerRollOffFactor(MT_Scalar rollofffactor) const +{ + // not implemented in openal +} + + + +void SND_FmodDevice::NextFrame() const +{ + FSOUND_3D_Update(); +} + + + +// set the gain for the listener +void SND_FmodDevice::SetListenerGain(float gain) const +{ + int fmod_gain = (int)(gain * 255); + FSOUND_SetSFXMasterVolume(fmod_gain); +} + + + +void SND_FmodDevice::InitListener() +{ + // initialize the listener with these values that won't change + // (as long as we can have only one listener) + // now we can superimpose all listeners on each other (for they + // have the same settings) + float lispos[3] = {0,0,0}; + float lisvel[3] = {0,0,0}; + + FSOUND_3D_Listener_SetAttributes(lispos, lisvel, 0, -1, 0, 0, 0, 1); +} + + + +// source playstate stuff //////////////////////////////////////////////////////////// + + + +// check if the sound's still playing +int SND_FmodDevice::GetPlayState(int id) +{ + int result = SND_STOPPED; + + // klopt niet, fixen + signed char isplaying = FSOUND_IsPlaying(id); + + if (isplaying) + { + result = SND_PLAYING; + } + +/* hi reevan, just swap // of these 2 lines */ +// return result; + return 0; +} + + + +/* sets the buffer */ +void SND_FmodDevice::SetObjectBuffer(int id, unsigned int buffer) +{ + m_sources[id] = m_buffers[buffer]; +} + + + +// make the source play +void SND_FmodDevice::PlayObject(int id) +{ + m_channels[id] = FSOUND_PlaySound(FSOUND_FREE, m_sources[id]); + m_frequencies[id] = FSOUND_GetFrequency(m_channels[id]); +// printf("fmod: play \n"); +} + + + +// make the source stop +void SND_FmodDevice::StopObject(int id) const +{ + FSOUND_StopSound(m_channels[id]); +// printf("fmod: stop \n"); +} + + + +// stop all sources +void SND_FmodDevice::StopAllObjects() +{ + FSOUND_StopSound(FSOUND_ALL); +} + + + +// pause the source +void SND_FmodDevice::PauseObject(int id) const +{ + FSOUND_StopSound(m_channels[id]); +} + + + +// source properties stuff //////////////////////////////////////////////////////////// + + + +// give openal the object's pitch +void SND_FmodDevice::SetObjectPitch(int id, MT_Scalar pitch) const +{ + pitch = pitch * m_frequencies[id]; + char result = FSOUND_SetFrequency(m_channels[id], (int)pitch); +} + + + +// give openal the object's gain +void SND_FmodDevice::SetObjectGain(int id, MT_Scalar gain) const +{ + int vol = (int)(gain * 255); + FSOUND_SetVolume(m_channels[id], vol); +} + + + +// give openal the object's looping +void SND_FmodDevice::SetObjectLoop(int id, unsigned int loopmode) const +{ +// printf("loopmode: %d\n", loopmode); + switch (loopmode) + { + case SND_LOOP_OFF: + { + char result = FSOUND_Sample_SetLoopMode(m_sources[id], FSOUND_LOOP_OFF); +// char result = FSOUND_SetLoopMode(m_channels[id], FSOUND_LOOP_OFF); + break; + } + case SND_LOOP_NORMAL: + { + char result = FSOUND_Sample_SetLoopMode(m_sources[id], FSOUND_LOOP_NORMAL); +// char result = FSOUND_SetLoopMode(m_channels[id], FSOUND_LOOP_NORMAL); + break; + } + case SND_LOOP_BIDIRECTIONAL: + { + char result = FSOUND_Sample_SetLoopMode(m_sources[id], FSOUND_LOOP_BIDI); +// char result = FSOUND_SetLoopMode(m_channels[id], FSOUND_LOOP_NORMAL); + break; + } + default: + break; + } +} + + + +void SND_FmodDevice::SetObjectLoopPoints(int id, unsigned int loopstart, unsigned int loopend) const +{ + FSOUND_Sample_SetLoopPoints(m_sources[id], loopstart, loopend); +} + + + +void SND_FmodDevice::SetObjectMinGain(int id, MT_Scalar mingain) const +{ + /* not supported by fmod */ +} + + + +void SND_FmodDevice::SetObjectMaxGain(int id, MT_Scalar maxgain) const +{ + /* not supported by fmod */ +} + + + +void SND_FmodDevice::SetObjectRollOffFactor(int id, MT_Scalar rollofffactor) const +{ + /* not supported by fmod */ +} + + + +void SND_FmodDevice::SetObjectReferenceDistance(int id, MT_Scalar referencedistance) const +{ + /* not supported by fmod */ +} + + + +// give openal the object's position +void SND_FmodDevice::ObjectIs2D(int id) const +{ + float obpos[3] = {0,0,0}; + float obvel[3] = {0,0,0}; + + FSOUND_3D_SetAttributes(m_channels[id], obpos, obvel); +} + + + +void SND_FmodDevice::SetObjectTransform(int id, + const MT_Vector3& position, + const MT_Vector3& velocity, + const MT_Matrix3x3& orientation, + const MT_Vector3& lisposition, + const MT_Scalar& rollofffactor) const +{ + float obpos[3]; + float obvel[3]; + + obpos[0] = (float)position[0] * (float)rollofffactor; //x (l/r) + obpos[1] = (float)position[1] * (float)rollofffactor; + obpos[2] = (float)position[2] * (float)rollofffactor; + + velocity.getValue(obvel); + FSOUND_3D_SetAttributes(m_channels[id], obpos, obvel); +} + + + +// cd support stuff //////////////////////////////////////////////////////////// + + +void SND_FmodDevice::PlayCD(int track) const +{ + signed char result = FSOUND_CD_Play(track); + +#ifdef ONTKEVER + printf("play track %d, result: %c\n", track, result); +#endif +} + + + +void SND_FmodDevice::PauseCD(bool pause) const +{ + signed char result = FSOUND_CD_SetPaused(pause); + +#ifdef ONTKEVER + printf("pause cd: %d, result: %c\n", pause, result); +#endif +} + + + +void SND_FmodDevice::StopCD() const +{ + SND_CDObject* pCD = SND_CDObject::Instance(); + + if (pCD) + { + if (pCD->GetUsed()) + { + signed char result = FSOUND_CD_Stop(); + +#ifdef ONTKEVER + printf("stop cd, result: %c\n", result); +#endif + } + } +} + + + +void SND_FmodDevice::SetCDPlaymode(int playmode) const +{ + FSOUND_CD_SetPlayMode(playmode); +} + + + +void SND_FmodDevice::SetCDGain(MT_Scalar gain) const +{ + int volume = gain * 255; + signed char result = FSOUND_CD_SetVolume(volume); + +#ifdef ONTKEVER + printf("gain: %f, volume: %d, result: %c\n", gain, volume, result); +#endif +} + + + +void SND_FmodDevice::StartUsingDSP() +{ + m_dspunit = FSOUND_DSP_GetFFTUnit(); + + FSOUND_DSP_SetActive(m_dspunit, true); +} + + + +float* SND_FmodDevice::GetSpectrum() +{ + m_spectrum = FSOUND_DSP_GetSpectrum(); + + return m_spectrum; +} + + + +void SND_FmodDevice::StopUsingDSP() +{ + if (m_dspunit) + FSOUND_DSP_SetActive(m_dspunit, false); +}
\ No newline at end of file diff --git a/intern/SoundSystem/fmod/SND_FmodDevice.h b/intern/SoundSystem/fmod/SND_FmodDevice.h new file mode 100644 index 00000000000..2a8dbcf0b30 --- /dev/null +++ b/intern/SoundSystem/fmod/SND_FmodDevice.h @@ -0,0 +1,105 @@ +/** + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ +#ifndef SND_FMODDEVICE +#define SND_FMODDEVICE + +#include "fmod.h" +#include "SND_AudioDevice.h" +#include "SoundDefines.h" + +class SND_FmodDevice : public SND_AudioDevice +{ +public: + SND_FmodDevice(); + ~SND_FmodDevice(); + + SND_WaveSlot* LoadSample(const STR_String& samplename, + void* memlocation, + int size); + + void InitListener(); + void SetListenerGain(float gain) const; + void SetDopplerVelocity(MT_Scalar dopplervelocity) const; + void SetDopplerFactor(MT_Scalar dopplerfactor) const; + void SetListenerRollOffFactor(MT_Scalar rollofffactor) const; + + void MakeCurrent() const; + void NextFrame() const; + void UseCD() const; + + void SetObjectBuffer(int id, unsigned int buffer); + int GetPlayState(int id); + void PlayObject(int id); + void StopObject(int id) const; + void StopAllObjects(); + void PauseObject(int id) const; + + void SetObjectLoop(int id, unsigned int loopmode) const; + void SetObjectLoopPoints(int id, unsigned int loopstart, unsigned int loopend) const; + void SetObjectPitch(int id, MT_Scalar pitch) const; + void SetObjectGain(int id, MT_Scalar gain) const; + void SetObjectMinGain(int id, MT_Scalar mingain) const; + void SetObjectMaxGain(int id, MT_Scalar maxgain) const; + void SetObjectRollOffFactor(int id, MT_Scalar rolloff) const; + void SetObjectReferenceDistance(int id, MT_Scalar distance) const; + + void SetObjectTransform(int id, + const MT_Vector3& position, + const MT_Vector3& velocity, + const MT_Matrix3x3& orientation, + const MT_Vector3& lisposition, + const MT_Scalar& rollofffactor) const; + void ObjectIs2D(int id) const; + + void PlayCD(int track) const; + void PauseCD(bool pause) const; + void StopCD() const; + void SetCDPlaymode(int playmode) const; + void SetCDGain(MT_Scalar gain) const; + + void StartUsingDSP(); + float* GetSpectrum(); + void StopUsingDSP(); + +private: + FSOUND_SAMPLE* m_buffers[NUM_BUFFERS]; + FSOUND_SAMPLE* m_sources[NUM_SOURCES]; + FSOUND_DSPUNIT* m_dspunit; + int m_frequencies[NUM_SOURCES]; + int m_max_channels; + int m_num_hardware_channels; + int m_num_software_channels; + int m_channels[NUM_SOURCES]; + float* m_spectrum; +}; + +#endif //SND_FMODDEVICE diff --git a/intern/SoundSystem/intern/Makefile b/intern/SoundSystem/intern/Makefile new file mode 100644 index 00000000000..ae5805ad5bc --- /dev/null +++ b/intern/SoundSystem/intern/Makefile @@ -0,0 +1,50 @@ +# +# $Id$ +# +# ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. The Blender +# Foundation also sells licenses for use in proprietary software under +# the Blender License. See http://www.blender.org/BL/ for information +# about this. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software Foundation, +# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +# +# The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. +# All rights reserved. +# +# The Original Code is: all of this file. +# +# Contributor(s): none yet. +# +# ***** END GPL/BL DUAL LICENSE BLOCK ***** +# +# + +LIBNAME = SoundSystem +DIR = $(OCGDIR)/gameengine/$(LIBNAME) + +include nan_compile.mk + +CCFLAGS += $(LEVEL_1_CPP_WARNINGS) + +CPPFLAGS += -I$(NAN_FMOD)/include +CPPFLAGS += -I$(NAN_STRING)/include +CPPFLAGS += -I$(NAN_MOTO)/include +CPPFLAGS += -I../../../kernel/gen_system +CPPFLAGS += -I../../../blender/include +CPPFLAGS += -I../dummy +CPPFLAGS += -I../fmod +CPPFLAGS += -I../openal +CPPFLAGS += -I.. +CPPFLAGS += -I. diff --git a/intern/SoundSystem/intern/SND_AudioDevice.cpp b/intern/SoundSystem/intern/SND_AudioDevice.cpp new file mode 100644 index 00000000000..20800153128 --- /dev/null +++ b/intern/SoundSystem/intern/SND_AudioDevice.cpp @@ -0,0 +1,247 @@ +/** + * $Id$ + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#include "SND_AudioDevice.h" + +#include "SND_SoundObject.h" + +#ifdef WIN32 +// This warning tells us about truncation of __long__ stl-generated names. +// It can occasionally cause DevStudio to have internal compiler warnings. +#pragma warning( disable : 4786 ) +#endif + + +SND_AudioDevice::SND_AudioDevice() +{ + m_wavecache = NULL; + m_audio = false; + + for (int i = 0; i < NUM_SOURCES; i++) + { + m_idObjectArray[i] = new SND_IdObject(); + m_idObjectArray[i]->SetId(i); + m_idObjectArray[i]->SetSoundObject(NULL); + m_idObjectList.addTail(m_idObjectArray[i]); + } +} + + + +SND_AudioDevice::~SND_AudioDevice() +{ + for (int i = 0; i < NUM_SOURCES; i++) + { + delete m_idObjectArray[i]; + m_idObjectArray[i] = NULL; + } + + if (m_wavecache) + { + delete m_wavecache; + m_wavecache = NULL; + } +} + + + +bool SND_AudioDevice::IsInitialized() +{ + return m_audio; +} + + + +SND_WaveCache* SND_AudioDevice::GetWaveCache() const +{ + return m_wavecache; +} + + + +/* seeks an unused id and returns it */ +bool SND_AudioDevice::GetNewId(SND_SoundObject* pObject) +{ +#ifdef ONTKEVER + printf("SND_AudioDevice::GetNewId\n"); +#endif + + bool result; + + // first, get the oldest (the first) idobject + SND_IdObject* pIdObject = (SND_IdObject*)m_idObjectList.getHead(); + + if (pIdObject->isTail()) + { + result = false; + } + else + { + // find the first id object which doesn't have a high priority soundobject + bool ThisSoundMustStay = false; + bool OutOfIds = false; + + do + { + // if no soundobject present, it's seat may be taken + if (pIdObject->GetSoundObject()) + { + // and also if it ain't highprio + if (pIdObject->GetSoundObject()->IsHighPriority()) + { + ThisSoundMustStay = true; + pIdObject = (SND_IdObject*)pIdObject->getNext(); + + // if the last one is a priority sound too, then there are no id's left + // and we won't add any new sounds + if (pIdObject->isTail()) + OutOfIds = true; + } + else + { + ThisSoundMustStay = false; + } + } + else + { + ThisSoundMustStay = false; + } + + } while (ThisSoundMustStay && !OutOfIds); + + if (!OutOfIds) + { + SND_SoundObject* oldobject = oldobject = pIdObject->GetSoundObject(); + + // revoke the old object if present + if (oldobject) + { +#ifdef ONTKEVER + printf("oldobject: %x\n", oldobject); +#endif + RevokeSoundObject(oldobject); + } + + // set the new soundobject into the idobject + pIdObject->SetSoundObject(pObject); + + // set the id into the soundobject + int id = pIdObject->GetId(); + pObject->SetId(id); + + // connect the new id to the buffer the sample is stored in + SetObjectBuffer(id, pObject->GetBuffer()); + + // remove the idobject from the list and add it in the back again + pIdObject->remove(); + m_idObjectList.addTail(pIdObject); + + result = true; + } + } + + return result; +} + + + +void SND_AudioDevice::ClearId(SND_SoundObject* pObject) +{ +#ifdef ONTKEVER + printf("SND_AudioDevice::ClearId\n"); +#endif + + if (pObject) + { + int id = pObject->GetId(); + + if (id != -1) + { + // lets get the idobject belonging to the soundobject + SND_IdObject* pIdObject = m_idObjectArray[id]; + SND_SoundObject* oldobject = pIdObject->GetSoundObject(); + + if (oldobject) + { + RevokeSoundObject(oldobject); + + // clear the idobject from the soundobject + pIdObject->SetSoundObject(NULL); + } + + // remove the idobject and place it in front + pIdObject->remove(); + m_idObjectList.addHead(pIdObject); + } + } +} + + + +void SND_AudioDevice::RevokeSoundObject(SND_SoundObject* pObject) +{ +#ifdef ONTKEVER + printf("SND_AudioDevice::RevokeSoundObject\n"); +#endif + + // stop the soundobject + int id = pObject->GetId(); + + if (id >= 0 && id < NUM_SOURCES) + { + StopObject(id); + + // remove the object from the 'activelist' + pObject->SetActive(false); + +#ifdef ONTKEVER + printf("pObject->remove();\n"); +#endif + } + + // make sure its id is invalid + pObject->SetId(-1); +} + +/* +void SND_AudioDevice::RemoveSample(const char* filename) +{ + if (m_wavecache) + m_wavecache->RemoveSample(filename); +} +*/ + +void SND_AudioDevice::RemoveAllSamples() +{ + if (m_wavecache) + m_wavecache->RemoveAllSamples(); +} + diff --git a/intern/SoundSystem/intern/SND_AudioDevice.h b/intern/SoundSystem/intern/SND_AudioDevice.h new file mode 100644 index 00000000000..54a8738e43f --- /dev/null +++ b/intern/SoundSystem/intern/SND_AudioDevice.h @@ -0,0 +1,118 @@ +/** + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ +#ifndef SND_AUDIODEVICE +#define SND_AUDIODEVICE + +#include "SND_IAudioDevice.h" +#include "SoundDefines.h" +#include "SND_IdObject.h" + + +class SND_AudioDevice : public SND_IAudioDevice +{ +public: + SND_AudioDevice(); + virtual ~SND_AudioDevice(); + + virtual bool IsInitialized(); + + SND_WaveCache* GetWaveCache() const; + + bool GetNewId(SND_SoundObject* pObject); + void ClearId(SND_SoundObject* pObject); + + void UseCD() const {}; + + /* to be implemented in derived class + + virtual SND_WaveSlot* LoadSample(const STR_String& samplename, + void* memlocation, + int size) =0; + */ +// void RemoveSample(const char* filename); + void RemoveAllSamples(); + + /* to be implemented in derived class + + virtual void InitListener()=0; + virtual void SetListenerGain(float gain) const =0; + virtual void SetDopplerVelocity(MT_Scalar dopplervelocity) const =0; + virtual void SetDopplerFactor(MT_Scalar dopplerfactor) const =0; + virtual void SetListenerRollOffFactor(MT_Scalar rollofffactor) const =0; + + virtual void MakeCurrent() const =0; + + virtual void UpdateDevice() const =0; + + virtual void SetObjectBuffer(int id, unsigned int buffer)=0; + virtual int GetPlayState(int id)=0; + virtual void PlayObject(int id)=0; + virtual void StopObject(int id) const =0; + virtual void StopAllObjects()=0; + virtual void PauseObject(int id) const =0; + + virtual void SetObjectLoop(int id, bool loop) const =0; + virtual void SetObjectLoopPoints(int id, unsigned int loopstart, unsigned int loopend) const =0; + virtual void SetObjectPitch(int id, MT_Scalar pitch) const =0; + virtual void SetObjectGain(int id, MT_Scalar gain) const =0; + virtual void SetObjectRollOffFactor(int id, MT_Scalar rolloff) const =0; + virtual void SetObjectMinGain(int id, MT_Scalar mingain) const =0; + virtual void SetObjectMaxGain(int id, MT_Scalar maxgain) const =0; + virtual void SetObjectReferenceDistance(int id, MT_Scalar referencedistance) const =0; + + virtual void SetObjectTransform(int id, + const MT_Vector3& position, + const MT_Vector3& velocity, + const MT_Matrix3x3& orientation, + const MT_Vector3& lisposition, + const MT_Scalar& rollofffactor) const =0; + virtual void ObjectIs2D(int id) const =0; + + virtual void PlayCD(int track) const =0; + virtual void PauseCD(bool pause) const =0; + virtual void StopCD() const =0; + virtual void SetCDPlaymode(int playmode) const =0; + virtual void SetCDGain(MT_Scalar gain) const =0; + virtual float* GetSpectrum() =0; + */ + +protected: + bool m_audio; + GEN_List m_idObjectList; + SND_IdObject* m_idObjectArray[NUM_SOURCES]; + SND_WaveCache* m_wavecache; + +private: + void RevokeSoundObject(SND_SoundObject* pObject); +}; + +#endif //SND_AUDIODEVICE diff --git a/intern/SoundSystem/intern/SND_C-api.cpp b/intern/SoundSystem/intern/SND_C-api.cpp new file mode 100644 index 00000000000..8a4fc8f31a6 --- /dev/null +++ b/intern/SoundSystem/intern/SND_C-api.cpp @@ -0,0 +1,391 @@ +/* + * SND_C-Api.cpp + * + * C Api for soundmodule + * + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#include "SND_C-api.h" +#include "SND_DeviceManager.h" +#include "SND_Scene.h" + +#ifdef WIN32 +#pragma warning (disable:4786) // get rid of stupid stl-visual compiler debug warning +#endif //WIN32 + + + +void SND_SetDeviceType(int device_type) +{ + SND_DeviceManager::SetDeviceType(device_type); +} + + + +SND_AudioDeviceInterfaceHandle SND_GetAudioDevice() +{ + SND_IAudioDevice* audiodevice = NULL; + + SND_DeviceManager::Subscribe(); + audiodevice = SND_DeviceManager::Instance(); + + if (!audiodevice->IsInitialized()) + { + SND_DeviceManager::SetDeviceType(snd_e_dummydevice); + audiodevice = SND_DeviceManager::Instance(); + } + + return (SND_AudioDeviceInterfaceHandle)audiodevice; +} + + + +void SND_ReleaseDevice() +{ + SND_DeviceManager::Unsubscribe(); +} + + + +int SND_IsPlaybackWanted(SND_SceneHandle scene) +{ + assert(scene); + bool result = ((SND_Scene*)scene)->IsPlaybackWanted(); + + return (int)result; +} + + + +// create a scene +SND_SceneHandle SND_CreateScene(SND_AudioDeviceInterfaceHandle audiodevice) +{ + // initialize sound scene and object + SND_Scene* scene = new SND_Scene((SND_IAudioDevice*)audiodevice); + + return (SND_SceneHandle)scene; +} + + + +void SND_DeleteScene(SND_SceneHandle scene) +{ + assert(scene); + delete (SND_Scene*)scene; +} + + + +int SND_AddSample(SND_SceneHandle scene, + const char* filename, + void* memlocation, + int size) +{ + assert(scene); + assert(memlocation); + int buffer = ((SND_Scene*)scene)->LoadSample(filename, memlocation, size); + + return buffer; +} + + + +void SND_RemoveAllSamples(SND_SceneHandle scene) +{ + assert(scene); + ((SND_Scene*)scene)->RemoveAllSamples(); +} + + + +int SND_CheckBuffer(SND_SceneHandle scene, SND_ObjectHandle object) +{ + assert(scene); + assert(object); + int result = (int)((SND_Scene*)scene)->CheckBuffer((SND_SoundObject*)object); + + return result; +} + + + +void SND_AddSound(SND_SceneHandle scene, SND_ObjectHandle object) +{ + assert(scene); + assert(object); + ((SND_Scene*)scene)->AddObject((SND_SoundObject *)object); +} + + + +void SND_RemoveSound(SND_SceneHandle scene, SND_ObjectHandle object) +{ + assert(scene); + assert(object); + ((SND_Scene*)scene)->DeleteObject((SND_SoundObject *)object); +} + + + +void SND_RemoveAllSounds(SND_SceneHandle scene) +{ + assert(scene); + ((SND_Scene*)scene)->RemoveAllObjects(); +} + + + +void SND_StopAllSounds(SND_SceneHandle scene) +{ + assert(scene); + ((SND_Scene*)scene)->StopAllObjects(); +} + + + +void SND_Proceed(SND_AudioDeviceInterfaceHandle audiodevice, SND_SceneHandle scene) +{ + assert(scene); + ((SND_Scene*)scene)->Proceed(); + ((SND_IAudioDevice*)audiodevice)->NextFrame(); +} + + + +SND_ListenerHandle SND_GetListener(SND_SceneHandle scene) +{ + assert(scene); + return (SND_ListenerHandle)((SND_Scene*)scene)->GetListener(); +} + + + +void SND_SetListenerGain(SND_SceneHandle scene, double gain) +{ + assert(scene); + SND_SoundListener* listener = ((SND_Scene*)scene)->GetListener(); + listener->SetGain((MT_Scalar)gain); +} + + + +void SND_SetDopplerFactor(SND_SceneHandle scene, double dopplerfactor) +{ + assert(scene); + SND_SoundListener* listener = ((SND_Scene*)scene)->GetListener(); + listener->SetDopplerFactor(dopplerfactor); +} + + + +void SND_SetDopplerVelocity(SND_SceneHandle scene, double dopplervelocity) +{ + assert(scene); + SND_SoundListener* listener = ((SND_Scene*)scene)->GetListener(); + listener->SetDopplerVelocity(dopplervelocity); +} + + + +// Object instantiation +SND_ObjectHandle SND_CreateSound() +{ + return (SND_ObjectHandle)new SND_SoundObject(); +} + + + +void SND_DeleteSound(SND_ObjectHandle object) +{ + assert(object); + delete (SND_SoundObject*)object; +} + + + +// Object control +void SND_StartSound(SND_SceneHandle scene, SND_ObjectHandle object) +{ + assert(scene); + assert(object); + ((SND_Scene*)scene)->AddActiveObject((SND_SoundObject*)object, 0); +} + + + +void SND_StopSound(SND_SceneHandle scene, SND_ObjectHandle object) +{ + assert(scene); + assert(object); + ((SND_Scene*)scene)->RemoveActiveObject((SND_SoundObject*)object); +} + + + +void SND_PauseSound(SND_SceneHandle scene, SND_ObjectHandle object) +{ + assert(scene); + assert(object); + ((SND_Scene*)scene)->RemoveActiveObject((SND_SoundObject*)object); +} + + + +void SND_SetSampleName(SND_ObjectHandle object, char* samplename) +{ + assert(object); + STR_String name = samplename; + ((SND_SoundObject*)object)->SetSampleName(name); +} + + + +void SND_SetGain(SND_ObjectHandle object, double gain) +{ + assert(object); + ((SND_SoundObject*)object)->SetGain(gain); +} + + + +void SND_SetMinimumGain(SND_ObjectHandle object, double minimumgain) +{ + assert(object); + ((SND_SoundObject*)object)->SetMinGain(minimumgain); +} + + + +void SND_SetMaximumGain(SND_ObjectHandle object, double maximumgain) +{ + assert(object); + ((SND_SoundObject*)object)->SetMaxGain(maximumgain); +} + + + +void SND_SetRollOffFactor(SND_ObjectHandle object, double rollofffactor) +{ + assert(object); + ((SND_SoundObject*)object)->SetRollOffFactor(rollofffactor); +} + + + +void SND_SetReferenceDistance(SND_ObjectHandle object, double referencedistance) +{ + assert(object); + ((SND_SoundObject*)object)->SetReferenceDistance(referencedistance); +} + + + +void SND_SetPitch(SND_ObjectHandle object, double pitch) +{ + assert(object); + ((SND_SoundObject*)object)->SetPitch(pitch); +} + + + +void SND_SetPosition(SND_ObjectHandle object, double* position) +{ + assert(object); + ((SND_SoundObject*)object)->SetPosition(position); +} + + + +void SND_SetVelocity(SND_ObjectHandle object, double* velocity) +{ + assert(object); + ((SND_SoundObject*)object)->SetVelocity(velocity); +} + + + +void SND_SetOrientation(SND_ObjectHandle object, double* orientation) +{ + assert(object); + ((SND_SoundObject*)object)->SetOrientation(orientation); +} + + + +void SND_SetLoopMode(SND_ObjectHandle object, int loopmode) +{ + assert(object); + ((SND_SoundObject*)object)->SetLoopMode(loopmode); +} + + + +void SND_SetLoopPoints(SND_ObjectHandle object, unsigned int loopstart, unsigned int loopend) +{ + assert(object); + ((SND_SoundObject*)object)->SetLoopStart(loopstart); + ((SND_SoundObject*)object)->SetLoopEnd(loopend); +} + + + +float SND_GetGain(SND_ObjectHandle object) +{ + assert(object); + MT_Scalar gain = ((SND_SoundObject*)object)->GetGain(); + return (float) gain; +} + + + +float SND_GetPitch(SND_ObjectHandle object) +{ + assert(object); + MT_Scalar pitch = ((SND_SoundObject*)object)->GetPitch(); + return (float) pitch; +} + + + +int SND_GetLoopMode(SND_ObjectHandle object) +{ + assert(object); + return ((SND_SoundObject*)object)->GetLoopMode(); +} + + + +int SND_GetPlaystate(SND_ObjectHandle object) +{ + assert(object); + return ((SND_SoundObject*)object)->GetPlaystate(); +} diff --git a/intern/SoundSystem/intern/SND_CDObject.cpp b/intern/SoundSystem/intern/SND_CDObject.cpp new file mode 100644 index 00000000000..97b502970b7 --- /dev/null +++ b/intern/SoundSystem/intern/SND_CDObject.cpp @@ -0,0 +1,182 @@ +/* + * SND_CDObject.cpp + * + * Implementation for CD playback + * + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#include "SND_CDObject.h" + + +SND_CDObject* SND_CDObject::m_instance = NULL; + +bool SND_CDObject::CreateSystem() +{ + bool result = false; + + if (!m_instance) + { + m_instance = new SND_CDObject(); + result = true; + } + + return result; +} + + + +bool SND_CDObject::DisposeSystem() +{ + bool result = false; + + if (m_instance) + { + delete m_instance; + m_instance = NULL; + result = true; + } + + return result; +} + + + +SND_CDObject* SND_CDObject::Instance() +{ + return m_instance; +} + + + +SND_CDObject::SND_CDObject() +{ + m_gain = 1; + m_playmode = SND_CD_ALL; + m_track = 1; + m_playstate = SND_STOPPED; + m_used = false; + + // don't set the cd standard on modified: + // if not used, we don't wanna touch it (performance) + m_modified = false; +} + + + +SND_CDObject::~SND_CDObject() +{ +} + + + +void SND_CDObject::SetGain(MT_Scalar gain) +{ + m_gain = gain; + m_modified = true; +} + + + +void SND_CDObject::SetPlaymode(int playmode) +{ + m_playmode = playmode; +} + + + +void SND_CDObject::SetPlaystate(int playstate) +{ + m_playstate = playstate; +} + + + +void SND_CDObject::SetTrack(int track) +{ + m_track = track; +} + + + +int SND_CDObject::GetTrack() const +{ + return m_track; +} + + + +MT_Scalar SND_CDObject::GetGain() const +{ + return m_gain; +} + + +int SND_CDObject::GetPlaystate() const +{ + return m_playstate; +} + + + +bool SND_CDObject::IsModified() const +{ + return m_modified; +} + + + +void SND_CDObject::SetModified(bool modified) +{ + m_modified = modified; +} + + + +int SND_CDObject::GetPlaymode() const +{ + return m_playmode; +} + + + +void SND_CDObject::SetUsed() +{ + m_used = true; +} + + + +bool SND_CDObject::GetUsed() +{ + return m_used; +} + diff --git a/intern/SoundSystem/intern/SND_DeviceManager.cpp b/intern/SoundSystem/intern/SND_DeviceManager.cpp new file mode 100644 index 00000000000..a3e72f8e9f6 --- /dev/null +++ b/intern/SoundSystem/intern/SND_DeviceManager.cpp @@ -0,0 +1,137 @@ +/* + * SND_DeviceManager.h + * + * singleton for creating, switching and deleting audiodevices + * + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#include "SND_DeviceManager.h" +#include "SND_DependKludge.h" +#include "SND_DummyDevice.h" +#ifdef USE_FMOD +#include "SND_FmodDevice.h" +#endif +#ifdef USE_OPENAL +#include "SND_OpenALDevice.h" +#endif + +SND_IAudioDevice* SND_DeviceManager::m_instance = NULL; +int SND_DeviceManager::m_subscriptions = 0; + +#ifdef USE_OPENAL +int SND_DeviceManager::m_device_type = snd_e_openaldevice; +#else +# ifdef USE_FMOD +int SND_DeviceManager::m_device_type = snd_e_fmoddevice; +# else +int SND_DeviceManager::m_device_type = snd_e_dummydevice; +# endif +#endif + +void SND_DeviceManager::Subscribe() +{ + ++m_subscriptions; +} + + + +void SND_DeviceManager::Unsubscribe() +{ + --m_subscriptions; + + // only release memory if there is a m_instance but no subscriptions left + if (m_subscriptions == 0 && m_instance) + { + delete m_instance; + m_instance = NULL; + } +} + + + +SND_IAudioDevice* SND_DeviceManager::Instance() +{ + // only give away an instance if there are subscriptions + if (m_subscriptions) + { + // if there's no instance yet, set and create a new one + if (m_instance == NULL) + { + SetDeviceType(m_device_type); + } + + return m_instance; + } + else + { + return NULL; + } +} + + + +void SND_DeviceManager::SetDeviceType(int device_type) +{ + // if we want to change devicetype, first delete the old one + if (m_instance) + { + delete m_instance; + m_instance = NULL; + } + + // let's create the chosen device + switch (device_type) + { +#ifdef USE_FMOD + case snd_e_fmoddevice: + { + m_instance = new SND_FmodDevice(); + m_device_type = device_type; + break; + } +#endif +#ifdef USE_OPENAL + case snd_e_openaldevice: + { + m_instance = new SND_OpenALDevice(); + m_device_type = device_type; + break; + } +#endif + default: + { + m_instance = new SND_DummyDevice(); + m_device_type = device_type; + break; + } + } +} diff --git a/intern/SoundSystem/intern/SND_IdObject.cpp b/intern/SoundSystem/intern/SND_IdObject.cpp new file mode 100644 index 00000000000..b7e13cacbe6 --- /dev/null +++ b/intern/SoundSystem/intern/SND_IdObject.cpp @@ -0,0 +1,75 @@ +/* + * SND_IdObject.cpp + * + * Object for storing runtime data, like id's, soundobjects etc + * + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#include "SND_IdObject.h" + +SND_IdObject::SND_IdObject() +{ +} + + + +SND_IdObject::~SND_IdObject() +{ +} + + + +SND_SoundObject* SND_IdObject::GetSoundObject() +{ + return m_soundObject; +} + + + +void SND_IdObject::SetSoundObject(SND_SoundObject* pObject) +{ + m_soundObject = pObject; +} + + + +int SND_IdObject::GetId() +{ + return m_id; +} + + + +void SND_IdObject::SetId(int id) +{ + m_id = id; +} diff --git a/intern/SoundSystem/intern/SND_IdObject.h b/intern/SoundSystem/intern/SND_IdObject.h new file mode 100644 index 00000000000..116479eb69a --- /dev/null +++ b/intern/SoundSystem/intern/SND_IdObject.h @@ -0,0 +1,59 @@ +/* + * SND_IdObject.h + * + * Object for storing runtime data, like id's, soundobjects etc + * + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#ifndef __SND_IDOBJECT_H +#define __SND_IDOBJECT_H + +#include "SND_SoundObject.h" +#include "GEN_List.h" +#include "SoundDefines.h" + +class SND_IdObject : public GEN_Link +{ + SND_SoundObject* m_soundObject; + int m_id; + +public: + SND_IdObject(); + virtual ~SND_IdObject(); + + SND_SoundObject* GetSoundObject(); + void SetSoundObject(SND_SoundObject* pObject); + + int GetId(); + void SetId(int id); +}; +#endif //__SND_OBJECT_H diff --git a/intern/SoundSystem/intern/SND_Scene.cpp b/intern/SoundSystem/intern/SND_Scene.cpp new file mode 100644 index 00000000000..5bc65f02359 --- /dev/null +++ b/intern/SoundSystem/intern/SND_Scene.cpp @@ -0,0 +1,569 @@ +/* +* SND_Scene.cpp +* +* The scene for sounds. +* +* $Id$ +* + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** +*/ + +#ifdef WIN32 +#pragma warning (disable:4786) // Get rid of stupid stl-visual compiler debug warning +#endif //WIN32 + +#include "SND_Scene.h" +#include "SND_DependKludge.h" +#include "SYS_System.h" +#include "SND_IAudioDevice.h" + +#include <stdlib.h> +#include <iostream> + +//static unsigned int tijd = 0; + +SND_Scene::SND_Scene(SND_IAudioDevice* audiodevice) + : m_audiodevice(audiodevice) +{ + if (m_audiodevice) + m_wavecache = m_audiodevice->GetWaveCache(); + + if (!m_wavecache || !audiodevice) + { + m_audio = false; + } + else + { + //if so, go ahead! + m_audio = true; +#ifdef ONTKEVER + printf("SND_Scene::SND_Scene() m_audio == true\n"); +#endif + m_audiodevice->InitListener(); + } + + IsPlaybackWanted(); +} + + + +SND_Scene::~SND_Scene() +{ + StopAllObjects(); +} + + + +// check if audioplayback is wanted +bool SND_Scene::IsPlaybackWanted() +{ + SYS_SystemHandle syshandle = SYS_GetSystem(); + int audio = SYS_GetCommandLineInt(syshandle,"noaudio",0); + + if ((audio == 0) && m_audiodevice && m_wavecache) + { + m_audioplayback = true; + } + else + { + StopAllObjects(); + m_audioplayback = false; + } + + return m_audioplayback; +} + + + +int SND_Scene::LoadSample(const STR_String& samplename, + void* memlocation, + int size) +{ + int result = -1; + + if (m_audiodevice) + { + SND_WaveSlot* waveslot = m_audiodevice->LoadSample(samplename, memlocation, size); + + if (waveslot) + result = waveslot->GetBuffer(); + } + + return result; +} + + + +void SND_Scene::RemoveAllSamples() +{ + if (m_audio && m_audiodevice) + m_audiodevice->RemoveAllSamples(); +} + + + +bool SND_Scene::CheckBuffer(SND_SoundObject* pObject) +{ + bool result = false; + + if (pObject && m_wavecache) + { + SND_WaveSlot* waveslot = m_wavecache->GetWaveSlot(pObject->GetSampleName()); + + if (waveslot) + { + pObject->SetBuffer(waveslot->GetBuffer()); + + result = true; + } + } + + return result; +} + + + +bool SND_Scene::IsSampleLoaded(STR_String& samplename) +{ + bool result = false; + + if (samplename && m_wavecache) + { + SND_WaveSlot* waveslot = m_wavecache->GetWaveSlot(samplename); + + if (waveslot && waveslot->IsLoaded()) + result = true; + } + + return result; +} + + + +void SND_Scene::AddObject(SND_SoundObject* pObject) +{ + if (m_audio) + { + STR_String samplename = pObject->GetSampleName(); + SND_WaveSlot* slot = NULL; + + // don't add the object if no valid sample is referenced + if (samplename != "") + { + // check if the sample is already loaded + slot = m_wavecache->GetWaveSlot(samplename); + } + + if (slot) + { + pObject->SetBuffer(slot->GetBuffer()); + + // needed for expected lifespan of the sample, but ain't necesary anymore i think + MT_Scalar samplelength = slot->GetNumberOfSamples(); + MT_Scalar samplerate = slot->GetSampleRate(); + MT_Scalar soundlength = samplelength/samplerate; + pObject->SetLength(soundlength); + + // add the object to the list + m_soundobjects.insert((SND_SoundObject*)pObject); + } + } +} + + + +void SND_Scene::SetListenerTransform(const MT_Vector3& pos, + const MT_Vector3& vel, + const MT_Matrix3x3& ori) +{ + if (m_audio) + { + GetListener()->SetPosition(pos); + GetListener()->SetVelocity(vel); + GetListener()->SetOrientation(ori); + } +} + + + +void SND_Scene::UpdateListener() +{ + // process the listener if modified + if (m_listener.IsModified()) + { + m_audiodevice->SetListenerGain(m_listener.GetGain()); + + // fmod doesn't support dopplervelocity, so just use the dopplerfactor instead +#ifdef USE_FMOD + m_audiodevice->SetDopplerFactor(m_listener.GetDopplerVelocity()); +#else + m_audiodevice->SetDopplerVelocity(m_listener.GetDopplerVelocity()); + m_audiodevice->SetDopplerFactor(m_listener.GetDopplerFactor()); +#endif + m_listener.SetModified(false); + } +} + + + +void SND_Scene::AddActiveObject(SND_SoundObject* pObject, MT_Scalar curtime) +{ + if (m_audio) + { + if (pObject) + { +#ifdef ONTKEVER + printf("SND_Scene::AddActiveObject\n"); +#endif + + // first check if the object is already on the list + if (pObject->IsActive()) + { + pObject->SetTimeStamp(curtime); + pObject->StartSound(); + } + else + { + pObject->SetTimeStamp(curtime); + + // compute the expected lifespan + pObject->SetLifeSpan(); + + // lets give the new active-to-be object an id + if (m_audiodevice->GetNewId(pObject)) + { + // and add the object + m_activeobjects.addTail(pObject); + pObject->StartSound(); + pObject->SetActive(true); + } + } + } + } +} + + + +void SND_Scene::RemoveActiveObject(SND_SoundObject* pObject) +{ + if (m_audio) + { + if (pObject) + { +#ifdef ONTKEVER + printf("SND_Scene::RemoveActiveObject\n"); +#endif + // if inactive, remove it from the list + if (pObject->IsActive()) + { + // first make sure it is stopped + m_audiodevice->ClearId(pObject); + } + } + } +} + + + +void SND_Scene::UpdateActiveObects() +{ +// ++tijd; + + SND_SoundObject* pObject; + // update only the objects that need to be updated + for (pObject = (SND_SoundObject*)m_activeobjects.getHead(); + !pObject->isTail(); + pObject = (SND_SoundObject*)pObject->getNext()) + { + int id = pObject->GetId(); + + if (id >= 0) + { + bool juststartedplaying = false; +#ifdef USE_FMOD + // fmod wants these set before playing the sample + if (pObject->IsModified()) + { + m_audiodevice->SetObjectLoop(id, pObject->GetLoopMode()); + m_audiodevice->SetObjectLoopPoints(id, pObject->GetLoopStart(), pObject->GetLoopEnd()); + } + + // ok, properties Set. now see if it must play + if (pObject->GetPlaystate() == SND_MUST_PLAY) + { + m_audiodevice->PlayObject(id); + pObject->SetPlaystate(SND_PLAYING); + pObject->InitRunning(); +// printf("start play: %d\n", tijd); + juststartedplaying = true; + } +#endif + if (pObject->Is3D()) + { + // Get the global positions and velocity vectors + // of the listener and soundobject + MT_Vector3 op = pObject->GetPosition(); + MT_Vector3 lp = m_listener.GetPosition(); + MT_Vector3 position = op - lp; + + // Calculate relative velocity in global coordinates + // of the sound with respect to the listener. + MT_Vector3 ov = pObject->GetVelocity(); + MT_Vector3 lv = m_listener.GetVelocity(); + MT_Vector3 velocity = ov - lv; + + // Now map the object position and velocity into + // the local coordinates of the listener. + MT_Matrix3x3 lo = m_listener.GetOrientation(); + + MT_Vector3 local_sound_pos = position * lo; + MT_Vector3 local_sound_vel = velocity * lo; + + m_audiodevice->SetObjectTransform( + id, + local_sound_pos, + local_sound_vel, + pObject->GetOrientation(), // make relative to listener! + lp, + pObject->GetRollOffFactor()); + } + else + { + m_audiodevice->ObjectIs2D(id); + } + + // update the situation + if (pObject->IsModified()) + { + m_audiodevice->SetObjectPitch(id, pObject->GetPitch()); + m_audiodevice->SetObjectGain(id, pObject->GetGain()); + m_audiodevice->SetObjectMinGain(id, pObject->GetMinGain()); + m_audiodevice->SetObjectMaxGain(id, pObject->GetMaxGain()); + m_audiodevice->SetObjectReferenceDistance(id, pObject->GetReferenceDistance()); + m_audiodevice->SetObjectRollOffFactor(id, pObject->GetRollOffFactor()); + m_audiodevice->SetObjectLoop(id, pObject->GetLoopMode()); + m_audiodevice->SetObjectLoopPoints(id, pObject->GetLoopStart(), pObject->GetLoopEnd()); + pObject->SetModified(false); + } + + pObject->AddRunning(); + +#ifdef ONTKEVER + STR_String naam = pObject->GetObjectName(); + STR_String sample = pObject->GetSampleName(); + + int id = pObject->GetId(); + int buffer = pObject->GetBuffer(); + + float gain = pObject->GetGain(); + float pitch = pObject->GetPitch(); + float timestamp = pObject->GetTimestamp(); + + printf("naam: %s, sample: %s \n", naam.Ptr(), sample.Ptr()); + printf("id: %d, buffer: %d \n", id, buffer); + printf("gain: %f, pitch: %f, ts: %f \n\n", gain, pitch, timestamp); +#endif +#ifdef USE_OPENAL + // ok, properties Set. now see if it must play + if (pObject->GetPlaystate() == SND_MUST_PLAY) + { + m_audiodevice->PlayObject(id); + pObject->SetPlaystate(SND_PLAYING); + //break; + } +#endif + + // check to see if the sound is still playing + // if not: release its id + int playstate = m_audiodevice->GetPlayState(id); +#ifdef ONTKEVER + if (playstate != 2) + printf("%d - ",playstate); +#endif + +// if ((playstate == SND_STOPPED && (!juststartedplaying) && !pObject->GetLoopMode() && pObject->IsRunning()) +#ifdef WIN32 + if ((playstate == SND_STOPPED) && !pObject->GetLoopMode()) +#else + if (!pObject->GetLoopMode()) +#endif + { +// printf("remove: %d\n", tijd); + RemoveActiveObject(pObject); + } + } + } +} + + + +void SND_Scene::UpdateCD() +{ + if (m_audiodevice) + { + SND_CDObject* pCD = SND_CDObject::Instance(); + + if (pCD) + { + int playstate = pCD->GetPlaystate(); + + switch (playstate) + { + case SND_MUST_PLAY: + { + // initialize the cd only when you need it + m_audiodevice->SetCDGain(pCD->GetGain()); + m_audiodevice->SetCDPlaymode(pCD->GetPlaymode()); + m_audiodevice->PlayCD(pCD->GetTrack()); + pCD->SetPlaystate(SND_PLAYING); + pCD->SetUsed(); + break; + } + case SND_MUST_PAUSE: + { + m_audiodevice->PauseCD(true); + pCD->SetPlaystate(SND_PAUSED); + break; + } + case SND_MUST_RESUME: + { + m_audiodevice->PauseCD(false); + pCD->SetPlaystate(SND_PLAYING); + break; + } + case SND_MUST_STOP: + { + m_audiodevice->StopCD(); + pCD->SetPlaystate(SND_STOPPED); + break; + } + default: + { + } + } + + // this one is only for realtime modifying settings + if (pCD->IsModified()) + { + m_audiodevice->SetCDGain(pCD->GetGain()); + pCD->SetModified(false); + } + } + } +} + + + +void SND_Scene::Proceed() +{ + if (m_audio && m_audioplayback) + { + m_audiodevice->MakeCurrent(); + + UpdateListener(); + UpdateActiveObects(); + UpdateCD(); + +// m_audiodevice->UpdateDevice(); + } +} + + +void SND_Scene::DeleteObject(SND_SoundObject* pObject) +{ +#ifdef ONTKEVER + printf("SND_Scene::DeleteObject\n"); +#endif + + if (pObject) + { + if (m_audiodevice) + m_audiodevice->ClearId(pObject); + + // must remove object from m_activeList + std::set<SND_SoundObject*>::iterator set_it; + set_it = m_soundobjects.find(pObject); + + if (set_it != m_soundobjects.end()) + m_soundobjects.erase(set_it); + + // release the memory + delete pObject; + pObject = NULL; + } +} + + + +void SND_Scene::RemoveAllObjects() +{ +#ifdef ONTKEVER + printf("SND_Scene::RemoveAllObjects\n"); +#endif + + StopAllObjects(); + + std::set<SND_SoundObject*>::iterator it = m_soundobjects.begin(); + + while (it != m_soundobjects.end()) + { + delete (*it); + it++; + } + + m_soundobjects.clear(); +} + + + +void SND_Scene::StopAllObjects() +{ + if (m_audio) + { +#ifdef ONTKEVER + printf("SND_Scene::StopAllObjects\n"); +#endif + + SND_SoundObject* pObject; + + for (pObject = (SND_SoundObject*)m_activeobjects.getHead(); + !pObject->isTail(); + pObject = (SND_SoundObject*)pObject->getNext()) + { + m_audiodevice->ClearId(pObject); + } + } +} + + + +SND_SoundListener* SND_Scene::GetListener() +{ + return &m_listener; +} diff --git a/intern/SoundSystem/intern/SND_SoundListener.cpp b/intern/SoundSystem/intern/SND_SoundListener.cpp new file mode 100644 index 00000000000..281da2aa7fb --- /dev/null +++ b/intern/SoundSystem/intern/SND_SoundListener.cpp @@ -0,0 +1,184 @@ +/* + * SND_SoundListener.cpp + * + * A SoundListener is for sound what a camera is for vision. + * + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#include "SND_SoundListener.h" + +SND_SoundListener::SND_SoundListener() +{ + m_modified = true; + m_gain = 1.0; + m_dopplerfactor = 1.0; + m_dopplervelocity = 1.0; + m_scale = 1.0; + m_position[0] = 0.0; + m_position[1] = 0.0; + m_position[2] = 0.0; + m_velocity[0] = 0.0; + m_velocity[1] = 0.0; + m_velocity[2] = 0.0; + m_orientation[0][0] = 1.0; + m_orientation[0][1] = 0.0; + m_orientation[0][2] = 0.0; + m_orientation[1][0] = 0.0; + m_orientation[1][1] = 1.0; + m_orientation[1][2] = 0.0; + m_orientation[2][0] = 0.0; + m_orientation[2][1] = 0.0; + m_orientation[2][2] = 1.0; +} + + +SND_SoundListener::~SND_SoundListener() +{ + ; /* intentionally empty */ + +} + + + +void SND_SoundListener::SetGain(MT_Scalar gain) +{ + m_gain = gain; + m_modified = true; +} + + + +void SND_SoundListener::SetPosition (const MT_Vector3& pos) +{ + m_position = pos; +} + + + +void SND_SoundListener::SetVelocity(const MT_Vector3& vel) +{ + m_velocity = vel; +} + + + +void SND_SoundListener::SetOrientation(const MT_Matrix3x3& ori) +{ + m_orientation = ori; +} + + + +void SND_SoundListener::SetDopplerFactor(MT_Scalar dopplerfactor) +{ + m_dopplerfactor = dopplerfactor; + m_modified = true; +} + + + +void SND_SoundListener::SetDopplerVelocity(MT_Scalar dopplervelocity) +{ + m_dopplervelocity = dopplervelocity; + m_modified = true; +} + + + +void SND_SoundListener::SetScale(MT_Scalar scale) +{ + m_scale = scale; + m_modified = true; +} + + + +MT_Scalar SND_SoundListener::GetGain() const +{ + return m_gain; +} + + + +MT_Vector3 SND_SoundListener::GetPosition() const +{ + return m_position; +} + + + +MT_Vector3 SND_SoundListener::GetVelocity() const +{ + return m_velocity; +} + + + +MT_Matrix3x3 SND_SoundListener::GetOrientation() +{ + return m_orientation; +} + + + +MT_Scalar SND_SoundListener::GetDopplerFactor() const +{ + return m_dopplerfactor; +} + + + +MT_Scalar SND_SoundListener::GetDopplerVelocity() const +{ + return m_dopplervelocity; +} + + + +MT_Scalar SND_SoundListener::GetScale() const +{ + return m_scale; +} + + + +bool SND_SoundListener::IsModified() const +{ + return m_modified; +} + + + +void SND_SoundListener::SetModified(bool modified) +{ + m_modified = modified; +} diff --git a/intern/SoundSystem/intern/SND_SoundObject.cpp b/intern/SoundSystem/intern/SND_SoundObject.cpp new file mode 100644 index 00000000000..69066d0a2dd --- /dev/null +++ b/intern/SoundSystem/intern/SND_SoundObject.cpp @@ -0,0 +1,506 @@ +/* + * SND_SoundObject.cpp + * + * Implementation of the abstract sound object + * + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#include "SND_SoundObject.h" + + + +SND_SoundObject::SND_SoundObject()// : m_modified(true) +{ + m_samplename = ""; + m_length = 0; + m_buffer = 0; + + m_gain = 0.0; + m_pitch = 1.0; + + m_mingain = 0.0; + m_maxgain = 1.0; + m_rollofffactor = 1.0; + m_referencedistance = 1.0; + + m_position[0] = 0.0; + m_position[1] = 0.0; + m_position[2] = 0.0; + m_velocity[0] = 0.0; + m_velocity[1] = 0.0; + m_velocity[2] = 0.0; + m_orientation[0][0] = 1.0; + m_orientation[0][1] = 0.0; + m_orientation[0][2] = 0.0; + m_orientation[1][0] = 0.0; + m_orientation[1][1] = 1.0; + m_orientation[1][2] = 0.0; + m_orientation[2][0] = 0.0; + m_orientation[2][1] = 0.0; + m_orientation[2][2] = 1.0; + + m_loopstart = 0; + m_loopend = 0; + m_loopmode = SND_LOOP_NORMAL; + m_is3d = true; + m_playstate = SND_INITIAL; + m_active = false; + m_id = -1; + m_lifespan = 0; + m_timestamp = 0; + m_modified = true; + m_running = 0; + m_highpriority = false; +} + + + +SND_SoundObject::~SND_SoundObject() +{ +} + + + +void SND_SoundObject::StartSound() +{ + m_playstate = SND_MUST_PLAY; +} + + + +void SND_SoundObject::StopSound() +{ + m_playstate = SND_MUST_STOP; +} + + + +void SND_SoundObject::PauseSound() +{ + m_playstate = SND_MUST_PAUSE; +} + + + +void SND_SoundObject::DeleteWhenFinished() +{ + m_playstate = SND_MUST_BE_DELETED; +} + + + +void SND_SoundObject::SetGain(MT_Scalar gain) +{ + m_gain = gain; + m_modified = true; +} + + + +void SND_SoundObject::SetMinGain(MT_Scalar mingain) +{ + m_mingain = mingain; + m_modified = true; +} + + + +void SND_SoundObject::SetMaxGain(MT_Scalar maxgain) +{ + m_maxgain = maxgain; + m_modified = true; +} + + + +void SND_SoundObject::SetRollOffFactor(MT_Scalar rollofffactor) +{ + m_rollofffactor = rollofffactor; + m_modified = true; +} + + + +void SND_SoundObject::SetReferenceDistance(MT_Scalar referencedistance) +{ + m_referencedistance = referencedistance; + m_modified = true; +} + + + +void SND_SoundObject::SetPitch(MT_Scalar pitch) +{ + m_pitch = pitch; + m_modified = true; +} + + + +void SND_SoundObject::SetLoopMode(unsigned int loopmode) +{ + m_loopmode = loopmode; + m_modified = true; +} + + + +void SND_SoundObject::SetLoopStart(unsigned int loopstart) +{ + m_loopstart = loopstart; + m_modified = true; +} + + + +void SND_SoundObject::SetLoopEnd(unsigned int loopend) +{ + m_loopend = loopend; + m_modified = true; +} + + + +void SND_SoundObject::Set3D(bool threedee) +{ + m_is3d = threedee; +} + + + +void SND_SoundObject::SetLifeSpan() +{ + m_lifespan = m_length / m_pitch; +} + + + +bool SND_SoundObject::IsLifeSpanOver(MT_Scalar curtime) const +{ + bool result = false; + + if ((curtime - m_timestamp) > m_lifespan) + result = true; + + return result; +} + + + +void SND_SoundObject::SetActive(bool active) +{ + m_active = active; + + if (!active) + { + m_playstate = SND_STOPPED; + (this)->remove(); + } +} + + + +void SND_SoundObject::SetBuffer(unsigned int buffer) +{ + m_buffer = buffer; +} + + + +void SND_SoundObject::SetObjectName(STR_String objectname) +{ + m_objectname = objectname; +} + + + +void SND_SoundObject::SetSampleName(STR_String samplename) +{ + m_samplename = samplename; +} + + + +void SND_SoundObject::SetLength(MT_Scalar length) +{ + m_length = length; +} + + + +void SND_SoundObject::SetPosition(const MT_Vector3& pos) +{ + m_position = pos; +} + + + +void SND_SoundObject::SetVelocity(const MT_Vector3& vel) +{ + m_velocity = vel; +} + + + +void SND_SoundObject::SetOrientation(const MT_Matrix3x3& orient) +{ + m_orientation = orient; +} + + + +void SND_SoundObject::SetPlaystate(int playstate) +{ + m_playstate = playstate; +} + + + +void SND_SoundObject::SetId(int id) +{ + m_id = id; +} + + + +void SND_SoundObject::SetTimeStamp(MT_Scalar timestamp) +{ + m_timestamp = timestamp; +} + + + +void SND_SoundObject::SetHighPriority(bool priority) +{ + m_highpriority = priority; +} + + + +bool SND_SoundObject::IsHighPriority() const +{ + return m_highpriority; +} + + + +bool SND_SoundObject::IsActive()const +{ + return m_active; +} + + + +int SND_SoundObject::GetId()const +{ + return m_id; +} + + + +MT_Scalar SND_SoundObject::GetLifeSpan()const +{ + return m_lifespan; +} + + + +MT_Scalar SND_SoundObject::GetTimestamp()const +{ + return m_timestamp; +} + + + +unsigned int SND_SoundObject::GetBuffer() +{ + return m_buffer; +} + + + +const STR_String& SND_SoundObject::GetSampleName() +{ + return m_samplename; +} + + + +const STR_String& SND_SoundObject::GetObjectName() +{ + return m_objectname; +} + + + +MT_Scalar SND_SoundObject::GetLength() const +{ + return m_length; +} + + + +MT_Scalar SND_SoundObject::GetGain() const +{ + return m_gain; +} + + + +MT_Scalar SND_SoundObject::GetPitch() const +{ + return m_pitch; +} + + + +MT_Scalar SND_SoundObject::GetMinGain() const +{ + return m_mingain; +} + + + +MT_Scalar SND_SoundObject::GetMaxGain() const +{ + return m_maxgain; +} + + + +MT_Scalar SND_SoundObject::GetRollOffFactor() const +{ + return m_rollofffactor; +} + + + +MT_Scalar SND_SoundObject::GetReferenceDistance() const +{ + return m_referencedistance; +} + + + +MT_Vector3 SND_SoundObject::GetPosition() const +{ + return m_position; +} + + + +MT_Vector3 SND_SoundObject::GetVelocity() const +{ + return m_velocity; +} + + + +MT_Matrix3x3 SND_SoundObject::GetOrientation() const +{ + return m_orientation; +} + + + +unsigned int SND_SoundObject::GetLoopMode() const +{ + return m_loopmode; +} + + + +unsigned int SND_SoundObject::GetLoopStart() const +{ + return m_loopstart; +} + + + +unsigned int SND_SoundObject::GetLoopEnd() const +{ + return m_loopend; +} + + + +bool SND_SoundObject::Is3D() const +{ + return m_is3d; +} + + + +int SND_SoundObject::GetPlaystate() const +{ + return m_playstate; +} + + + +bool SND_SoundObject::IsModified() const +{ + return m_modified; +} + + + +void SND_SoundObject::SetModified(bool modified) +{ + m_modified = modified; +} + + + +void SND_SoundObject::InitRunning() +{ + m_running = 0; +} + + + +bool SND_SoundObject::IsRunning() const +{ + bool result = false; + + if (m_running > 100) + result = true; + + return result; +} + + + +void SND_SoundObject::AddRunning() +{ + ++m_running; +} diff --git a/intern/SoundSystem/intern/SND_Utils.cpp b/intern/SoundSystem/intern/SND_Utils.cpp new file mode 100644 index 00000000000..3965c534cd3 --- /dev/null +++ b/intern/SoundSystem/intern/SND_Utils.cpp @@ -0,0 +1,395 @@ +/* + * SND_Utils.cpp + * + * Util functions for soundthingies + * + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#include "SND_Utils.h" +#include "SoundDefines.h" +#include "SND_DependKludge.h" +/* +extern "C" { +#include "license_key.h" +} +*/ +#include <stdio.h> +#include <stdlib.h> +#include <fcntl.h> +#include <math.h> +#include <string.h> + +#if defined(WIN32) +#include <io.h> +#else +#include <unistd.h> +#endif + +//extern int LICENSE_KEY_VALID; +#define LICENSE_KEY_VALID true + +#define BUFFERSIZE 32 + +/* loads a file */ +void* SND_LoadSample(char *filename) +{ + int file, filelen, buffersize = BUFFERSIZE; + void* data = NULL; + +#if defined(WIN32) + file = open(filename, O_BINARY|O_RDONLY); +#else + file = open(filename, 0|O_RDONLY); +#endif + + if (file == -1) + { + //printf("can't open file.\n"); + //printf("press q for quit.\n"); + } + else + { + filelen = lseek(file, 0, SEEK_END); + lseek(file, 0, SEEK_SET); + + if (filelen != 0) + { + data = malloc(buffersize); + + if (read(file, data, buffersize) != buffersize) + { + free(data); + data = NULL; + } + } + close(file); + + } + return (data); +} + + + +bool SND_IsSampleValid(const STR_String& name, void* memlocation) +{ + bool result = false; + bool loadedsample = false; + char buffer[BUFFERSIZE]; + + if (!memlocation) + { + STR_String samplename = name; + memlocation = SND_LoadSample(samplename.Ptr()); + + if (memlocation) + loadedsample = true; + } + + if (memlocation) + { + memcpy(&buffer, memlocation, BUFFERSIZE); + + if(!(memcmp(buffer, "RIFF", 4) && memcmp(&(buffer[8]), "WAVEfmt ", 8))) + { + int shortbuf = * ((short *) &buffer[20]); + if (shortbuf == SND_WAVE_FORMAT_PCM) + result = true; + + /* only fmod supports compressed wav */ +#ifdef USE_FMOD + /* and only valid publishers may use compressed wav */ + if (LICENSE_KEY_VALID) + { + switch (shortbuf) + { + case SND_WAVE_FORMAT_ADPCM: + case SND_WAVE_FORMAT_ALAW: + case SND_WAVE_FORMAT_MULAW: + case SND_WAVE_FORMAT_DIALOGIC_OKI_ADPCM: + case SND_WAVE_FORMAT_CONTROL_RES_VQLPC: + case SND_WAVE_FORMAT_GSM_610: + case SND_WAVE_FORMAT_MPEG3: + result = true; + break; + default: + { + break; + } + } + } +#endif + } +#ifdef USE_FMOD + /* only valid publishers may use ogg vorbis */ + else if (!memcmp(buffer, "OggS", 4) && LICENSE_KEY_VALID) + { + result = true; + } + /* only valid publishers may use mp3 */ + else if (((!memcmp(buffer, "ID3", 3)) || (!memcmp(buffer, "ÿû", 2))) && LICENSE_KEY_VALID) + { + result = true; + } +#endif + } + if (loadedsample) + { + free(memlocation); + memlocation = NULL; + } + + return result; +} + + + +/* checks if the passed pointer is a valid sample */ +bool CheckSample(void* sample) +{ + bool valid = false; + char buffer[32]; + + memcpy(buffer, sample, 16); + + if(!(memcmp(buffer, "RIFF", 4) && memcmp(&(buffer[8]), "WAVEfmt ", 8))) + { + valid = true; + } + + return valid; +} + + + +/* gets the type of the sample (0 == unknown, 1 == PCM etc */ +unsigned int SND_GetSampleFormat(void* sample) +{ + short sampletype = 0; + + if (CheckSample(sample)) + { + memcpy(&sampletype, ((char*)sample) + 20, 2); + } + + return (unsigned int)sampletype; +} + + + +/* gets the number of channels in a sample */ +unsigned int SND_GetNumberOfChannels(void* sample) +{ + short numberofchannels = 0; + + if (CheckSample(sample)) + { + memcpy(&numberofchannels, ((char*)sample) + 22, 2); + } + + return (unsigned int)numberofchannels; +} + + + +/* gets the samplerate of a sample */ +unsigned int SND_GetSampleRate(void* sample) +{ + unsigned int samplerate = 0; + + if (CheckSample(sample)) + { + memcpy(&samplerate, ((char*)sample) + 24, 4); + } + + return samplerate; +} + + + +/* gets the bitrate of a sample */ +unsigned int SND_GetBitRate(void* sample) +{ + short bitrate = 0; + + if (CheckSample(sample)) + { + memcpy(&bitrate, ((char*)sample) + 34, 2); + } + + return (unsigned int)bitrate; +} + + + +/* gets the length of the actual sample data (without the header) */ +unsigned int SND_GetNumberOfSamples(void* sample) +{ + unsigned int chunklength, length = 0, offset = 16; + char data[4]; + + if (CheckSample(sample)) + { + memcpy(&chunklength, ((char*)sample) + offset, 4); + offset = offset + chunklength + 4; + memcpy(data, ((char*)sample) + offset, 4); + + // lets find "data" + while (memcmp(data, "data", 4)) + { + offset += 4; + memcpy(data, ((char*)sample) + offset, 4); + } + offset += 4; + memcpy(&length, ((char*)sample) + offset, 4); + } + + return length; +} + + + +/* gets the size of the entire header (file - sampledata) */ +unsigned int SND_GetHeaderSize(void* sample) +{ + unsigned int chunklength, headersize = 0, offset = 16; + char data[4]; + + if (CheckSample(sample)) + { + memcpy(&chunklength, ((char*)sample) + offset, 4); + offset = offset + chunklength + 4; + memcpy(data, ((char*)sample) + offset, 4); + + // lets find "data" + while (memcmp(data, "data", 4)) + { + offset += 4; + memcpy(data, ((char*)sample) + offset, 4); + } + headersize = offset + 8; + } + + + return headersize; +} + + + +unsigned int SND_GetExtraChunk(void* sample) +{ + unsigned int extrachunk = 0, chunklength, offset = 16; + char data[4]; + + if (CheckSample(sample)) + { + memcpy(&chunklength, ((char*)sample) + offset, 4); + offset = offset + chunklength + 4; + memcpy(data, ((char*)sample) + offset, 4); + + // lets find "cue" + while (memcmp(data, "cue", 3)) + { + offset += 4; + memcpy(data, ((char*)sample) + offset, 4); + } + } + + return extrachunk; +} + + + +void SND_GetSampleInfo(signed char* sample, SND_WaveSlot* waveslot) +{ + WavFileHeader fileheader; + WavFmtHeader fmtheader; + WavFmtExHeader fmtexheader; + WavSampleHeader sampleheader; + WavChunkHeader chunkheader; + + if (CheckSample(sample)) + { + memcpy(&fileheader, sample, sizeof(WavFileHeader)); + sample += sizeof(WavFileHeader); + fileheader.size = ((fileheader.size+1) & ~1) - 4; + + while ((fileheader.size != 0) && (memcpy(&chunkheader, sample, sizeof(WavChunkHeader)))) + { + sample += sizeof(WavChunkHeader); + if (!memcmp(chunkheader.id, "fmt ", 4)) + { + memcpy(&fmtheader, sample, sizeof(WavFmtHeader)); + waveslot->SetSampleFormat(fmtheader.format); + + if (fmtheader.format == 0x0001) + { + waveslot->SetNumberOfChannels(fmtheader.numberofchannels); + waveslot->SetBitRate(fmtheader.bitrate); + waveslot->SetSampleRate(fmtheader.samplerate); + sample += chunkheader.size; + } + else + { + memcpy(&fmtexheader, sample, sizeof(WavFmtExHeader)); + sample += chunkheader.size; + } + } + else if (!memcmp(chunkheader.id, "data", 4)) + { + if (fmtheader.format == 0x0001) + { + waveslot->SetNumberOfSamples(chunkheader.size); + sample += chunkheader.size; + } + else if (fmtheader.format == 0x0011) + { + //IMA ADPCM + } + else if (fmtheader.format == 0x0055) + { + //MP3 WAVE + } + } + else if (!memcmp(chunkheader.id, "smpl", 4)) + { + memcpy(&sampleheader, sample, sizeof(WavSampleHeader)); + //loop = sampleheader.loops; + sample += chunkheader.size; + } + else + sample += chunkheader.size; + + sample += chunkheader.size & 1; + fileheader.size -= (((chunkheader.size + 1) & ~1) + 8); + } + } +} diff --git a/intern/SoundSystem/intern/SND_WaveCache.cpp b/intern/SoundSystem/intern/SND_WaveCache.cpp new file mode 100644 index 00000000000..279bc29aa83 --- /dev/null +++ b/intern/SoundSystem/intern/SND_WaveCache.cpp @@ -0,0 +1,134 @@ +/* + * SND_WaveCache.cpp + * + * abstract wavecache, a way to organize samples + * + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#ifdef WIN32 +#pragma warning (disable:4786) // Get rid of stupid stl-visual compiler debug warning +#endif //WIN32 + +#include "SND_WaveCache.h" +#include <stdio.h> + +#ifndef __APPLE__ +#include <malloc.h> +#else // __APPLE__ +#include <sys/malloc.h> +#endif // __APPLE__ + + +SND_WaveCache::SND_WaveCache() +{ + // do the buffer administration + for (int i = 0; i < NUM_BUFFERS; i++) + m_bufferList[i] = NULL; +} + + + +SND_WaveCache::~SND_WaveCache() +{ + // clean up the mess + FreeSamples(); + RemoveAllSamples(); +} + + + +SND_WaveSlot* SND_WaveCache::GetWaveSlot(const STR_String& samplename) +{ + SND_WaveSlot* waveslot = NULL; + + std::map<STR_String, SND_WaveSlot*>::iterator find_result = m_samplecache.find(samplename); + + // let's see if we have already loaded this sample + if (find_result != m_samplecache.end()) + { + waveslot = (*find_result).second; + } + else + { + // so the sample wasn't loaded, so do it here + for (int bufnum = 0; bufnum < NUM_BUFFERS; bufnum++) + { + // find an empty buffer + if (m_bufferList[bufnum] == NULL) + { + waveslot = new SND_WaveSlot(); + waveslot->SetSampleName(samplename); + waveslot->SetBuffer(bufnum); + m_bufferList[bufnum] = waveslot; + break; + } + } + m_samplecache.insert(std::pair<STR_String, SND_WaveSlot*>(samplename, waveslot)); + } + + return waveslot; +} + + + +void SND_WaveCache::RemoveAllSamples() +{ + // remove all samples + m_samplecache.clear(); + + // reset the list of buffers + for (int i = 0; i < NUM_BUFFERS; i++) + m_bufferList[i] = NULL; +} + + + +void SND_WaveCache::RemoveSample(const STR_String& samplename, int buffer) +{ + m_samplecache.erase(samplename); + m_bufferList[buffer] = NULL; +} + + + +void SND_WaveCache::FreeSamples() +{ + // iterate through the bufferlist and delete the waveslot if present + for (int i = 0; i < NUM_BUFFERS; i++) + { + if (m_bufferList[i]) + { + delete m_bufferList[i]; + m_bufferList[i] = NULL; + } + } +} diff --git a/intern/SoundSystem/intern/SND_WaveSlot.cpp b/intern/SoundSystem/intern/SND_WaveSlot.cpp new file mode 100644 index 00000000000..51356bba4bf --- /dev/null +++ b/intern/SoundSystem/intern/SND_WaveSlot.cpp @@ -0,0 +1,182 @@ +/** + * $Id$ + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + + +#include "SND_WaveSlot.h" + + + +SND_WaveSlot::~SND_WaveSlot() +{ +#ifdef ONTKEVER + printf("neeeeeee...\n"); +#endif +} + + + +void SND_WaveSlot::SetSampleName(STR_String samplename) +{ + m_samplename = samplename; +} + + + +void SND_WaveSlot::SetLoaded(bool loaded) +{ + m_loaded = loaded; +} + + + +void SND_WaveSlot::SetData(void* data) +{ + m_data = data; +} + + + +void SND_WaveSlot::SetBuffer(unsigned int buffer) +{ + m_buffer = buffer; +} + + + +void SND_WaveSlot::SetSampleFormat(unsigned int sampleformat) +{ + m_sampleformat = sampleformat; +} + + + +void SND_WaveSlot::SetNumberOfChannels(unsigned int numberofchannels) +{ + m_numberofchannels = numberofchannels; +} + + + +void SND_WaveSlot::SetSampleRate(unsigned int samplerate) +{ + m_samplerate = samplerate; +} + + + +void SND_WaveSlot::SetBitRate(unsigned int bitrate) +{ + m_bitrate = bitrate; +} + + + +void SND_WaveSlot::SetNumberOfSamples(unsigned int numberofsamples) +{ + m_numberofsamples = numberofsamples; +} + + + +void SND_WaveSlot::SetFileSize(unsigned int filesize) +{ + m_filesize = filesize; +} + + + +const STR_String& SND_WaveSlot::GetSampleName() +{ + return m_samplename; +} + + + +bool SND_WaveSlot::IsLoaded() const +{ + return m_loaded; +} + + + +void* SND_WaveSlot::GetData() +{ + return m_data; +} + + + +unsigned int SND_WaveSlot::GetBuffer() const +{ + return m_buffer; +} + + + +unsigned int SND_WaveSlot::GetSampleFormat() const +{ + return m_sampleformat; +} + + + +unsigned int SND_WaveSlot::GetNumberOfChannels() const +{ + return m_numberofchannels; +} + + + +unsigned int SND_WaveSlot::GetSampleRate() const +{ + return m_samplerate; +} + + + +unsigned int SND_WaveSlot::GetBitRate() const +{ + return m_bitrate; +} + + + +unsigned int SND_WaveSlot::GetNumberOfSamples() const +{ + return m_numberofsamples; +} + + + +unsigned int SND_WaveSlot::GetFileSize() const +{ + return m_filesize; +} diff --git a/intern/SoundSystem/openal/Makefile b/intern/SoundSystem/openal/Makefile new file mode 100644 index 00000000000..277332abde6 --- /dev/null +++ b/intern/SoundSystem/openal/Makefile @@ -0,0 +1,47 @@ +# +# $Id$ +# +# ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. The Blender +# Foundation also sells licenses for use in proprietary software under +# the Blender License. See http://www.blender.org/BL/ for information +# about this. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software Foundation, +# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +# +# The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. +# All rights reserved. +# +# The Original Code is: all of this file. +# +# Contributor(s): none yet. +# +# ***** END GPL/BL DUAL LICENSE BLOCK ***** +# +# + +LIBNAME = OpenALSoundSystem +DIR = $(OCGDIR)/gameengine/$(LIBNAME) + +include nan_compile.mk + +CCFLAGS += $(LEVEL_1_CPP_WARNINGS) + +CPPFLAGS += -I$(NAN_OPENAL)/include +CPPFLAGS += -I$(NAN_STRING)/include +CPPFLAGS += -I$(NAN_MOTO)/include +CPPFLAGS += -I../../../kernel/gen_system +CPPFLAGS += -I../intern +CPPFLAGS += -I.. +CPPFLAGS += -I. diff --git a/intern/SoundSystem/openal/SND_OpenALDevice.cpp b/intern/SoundSystem/openal/SND_OpenALDevice.cpp new file mode 100644 index 00000000000..a5cbf8d3300 --- /dev/null +++ b/intern/SoundSystem/openal/SND_OpenALDevice.cpp @@ -0,0 +1,661 @@ +/* + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + * SND_OpenALDevice derived from SND_IAudioDevice + */ + +#ifdef WIN32 +#pragma warning (disable:4786) // get rid of stupid stl-visual compiler debug warning +#endif //WIN32 + +#include "SND_OpenALDevice.h" +#include "SoundDefines.h" +#include "SYS_System.h" + +#include "SND_Utils.h" + +#include <AL/al.h> +#include <AL/alc.h> +#include <AL/alut.h> + +#include <stdio.h> +#include <stdlib.h> +#if defined(WIN32) +#include <io.h> +#else +#include <unistd.h> +#endif +#include <fcntl.h> + +/* untill openal gets unified we need this hack for non-windows systems */ +#ifndef WIN32 + +#include <malloc.h> + +ALvoid alutLoadWAVMemory(ALbyte *memory,ALenum *format,ALvoid **data,ALsizei *size,ALsizei *freq,ALboolean *loop); +ALvoid alutUnloadWAV(ALenum format,ALvoid *data,ALsizei size,ALsizei freq); + +typedef struct /* WAV File-header */ +{ + ALubyte Id[4]; + ALsizei Size; + ALubyte Type[4]; +} WAVFileHdr_Struct; + +typedef struct /* WAV Fmt-header */ +{ + ALushort Format; + ALushort Channels; + ALuint SamplesPerSec; + ALuint BytesPerSec; + ALushort BlockAlign; + ALushort BitsPerSample; +} WAVFmtHdr_Struct; + +typedef struct /* WAV FmtEx-header */ +{ + ALushort Size; + ALushort SamplesPerBlock; +} WAVFmtExHdr_Struct; + +typedef struct /* WAV Smpl-header */ +{ + ALuint Manufacturer; + ALuint Product; + ALuint SamplePeriod; + ALuint Note; + ALuint FineTune; + ALuint SMPTEFormat; + ALuint SMPTEOffest; + ALuint Loops; + ALuint SamplerData; + struct + { + ALuint Identifier; + ALuint Type; + ALuint Start; + ALuint End; + ALuint Fraction; + ALuint Count; + } Loop[1]; +} WAVSmplHdr_Struct; + +typedef struct /* WAV Chunk-header */ +{ + ALubyte Id[4]; + ALuint Size; +} WAVChunkHdr_Struct; + +ALvoid alutLoadWAVMemory(ALbyte *memory,ALenum *format,ALvoid **data,ALsizei *size,ALsizei *freq,ALboolean *loop) +{ + WAVChunkHdr_Struct ChunkHdr; + WAVFmtExHdr_Struct FmtExHdr; + WAVFileHdr_Struct FileHdr; + WAVSmplHdr_Struct SmplHdr; + WAVFmtHdr_Struct FmtHdr; + ALbyte *Stream; + + *format=AL_FORMAT_MONO16; + *data=NULL; + *size=0; + *freq=22050; + *loop=AL_FALSE; + if (memory) + { + Stream=memory; + if (Stream) + { + memcpy(&FileHdr,Stream,sizeof(WAVFileHdr_Struct)); + Stream+=sizeof(WAVFileHdr_Struct); + FileHdr.Size=((FileHdr.Size+1)&~1)-4; + while ((FileHdr.Size!=0)&&(memcpy(&ChunkHdr,Stream,sizeof(WAVChunkHdr_Struct)))) + { + Stream+=sizeof(WAVChunkHdr_Struct); + if (!memcmp(ChunkHdr.Id,"fmt ",4)) + { + memcpy(&FmtHdr,Stream,sizeof(WAVFmtHdr_Struct)); + if (FmtHdr.Format==0x0001) + { + *format=(FmtHdr.Channels==1? + (FmtHdr.BitsPerSample==8?AL_FORMAT_MONO8:AL_FORMAT_MONO16): + (FmtHdr.BitsPerSample==8?AL_FORMAT_STEREO8:AL_FORMAT_STEREO16)); + *freq=FmtHdr.SamplesPerSec; + Stream+=ChunkHdr.Size; + } + else + { + memcpy(&FmtExHdr,Stream,sizeof(WAVFmtExHdr_Struct)); + Stream+=ChunkHdr.Size; + } + } + else if (!memcmp(ChunkHdr.Id,"data",4)) + { + if (FmtHdr.Format==0x0001) + { + *size=ChunkHdr.Size; + *data=malloc(ChunkHdr.Size+31); + if (*data) memcpy(*data,Stream,ChunkHdr.Size); + memset(((char *)*data)+ChunkHdr.Size,0,31); + Stream+=ChunkHdr.Size; + } + else if (FmtHdr.Format==0x0011) + { + //IMA ADPCM + } + else if (FmtHdr.Format==0x0055) + { + //MP3 WAVE + } + } + else if (!memcmp(ChunkHdr.Id,"smpl",4)) + { + memcpy(&SmplHdr,Stream,sizeof(WAVSmplHdr_Struct)); + *loop = (SmplHdr.Loops ? AL_TRUE : AL_FALSE); + Stream+=ChunkHdr.Size; + } + else Stream+=ChunkHdr.Size; + Stream+=ChunkHdr.Size&1; + FileHdr.Size-=(((ChunkHdr.Size+1)&~1)+8); + } + } + } +} + +ALvoid alutUnloadWAV(ALenum format,ALvoid *data,ALsizei size,ALsizei freq) +{ + if (data) + free(data); +} + +#endif /* WIN32 */ + + + +SND_OpenALDevice::SND_OpenALDevice() +{ + // check if audio is wanted + SYS_SystemHandle syshandle = SYS_GetSystem(); + int audio = SYS_GetCommandLineInt(syshandle,"noaudio",0); + + if (audio != 0) + m_audio = false; + else + m_audio = true; + + m_buffersinitialized = false; + m_sourcesinitialized = false; + + // let's check if we can get openal to initialize... + if (m_audio) + { +#ifdef OUDE_OPENAL + m_audio = true; // openal_2.12 + alutInit(NULL, NULL); // openal_2.12 +#else + m_audio = false; + + ALCdevice *dev = alcOpenDevice(NULL); + if (dev) { + m_context = alcCreateContext(dev, NULL); + + if (m_context) { + alcMakeContextCurrent(m_context); + m_audio = true; + } + } + +#endif + } + + // then try to generate some buffers + if (m_audio) + { + // let openal generate its buffers + alGenBuffers(NUM_BUFFERS, m_buffers); + m_buffersinitialized = true; + + for (int i = 0; i < NUM_BUFFERS; i++) + { + if (!alIsBuffer(m_buffers[i])) + { + //printf("\n\n WARNING: OpenAL returned with an error. Continuing without audio.\n\n"); + m_audio = false; + break; + } + } + } + + // next: the sources + if (m_audio) + { +#ifdef OUDE_OPENAL + ALenum alc_error = ALC_NO_ERROR; // openal_2.12 +#else + ALenum alc_error = alcGetError(); // openal_2.14+ +#endif + + // let openal generate its sources + if (alc_error == ALC_NO_ERROR) + { + alGenSources(NUM_SOURCES, m_sources); + m_sourcesinitialized = true; + } + } + + // let's get us a wavecache + if (m_audio) + { + m_wavecache = new SND_WaveCache(); + } +} + + + +void SND_OpenALDevice::MakeCurrent() const +{ +#ifdef WIN32 + alcMakeContextCurrent(m_context); +#endif +} + + + +SND_OpenALDevice::~SND_OpenALDevice() +{ + if (m_context) { + alcMakeContextCurrent(m_context); + + if (m_buffersinitialized) + alDeleteBuffers(NUM_BUFFERS, m_buffers); + + if (m_sourcesinitialized) + alDeleteSources(NUM_SOURCES, m_sources); + } +} + + + +SND_WaveSlot* SND_OpenALDevice::LoadSample(const STR_String& name, + void* memlocation, + int size) +{ + SND_WaveSlot* waveslot = NULL; + STR_String samplename = name; + + if (m_audio) + { + /* create the waveslot */ + waveslot = m_wavecache->GetWaveSlot(samplename); + + /* do we support this sample? */ + if (SND_IsSampleValid(name, memlocation)) + { + if (waveslot) + { + int buffer = waveslot->GetBuffer(); + void* data = NULL; + char loop = 'a'; + int sampleformat, bitrate, numberofchannels; + ALenum al_error = alGetError(); + +#ifdef OUDE_OPENAL + unsigned int samplerate, numberofsamples; // openal_2.12 +#else + int samplerate, numberofsamples, frequency; // openal_2.14+ +#endif + + /* load the sample from memory? */ + if (size && memlocation) + { + waveslot->SetFileSize(size); + + /* what was (our) buffer? */ + int buffer = waveslot->GetBuffer(); + + /* get some info out of the sample */ + SND_GetSampleInfo((signed char*)memlocation, waveslot); + numberofchannels = SND_GetNumberOfChannels(memlocation); + bitrate = SND_GetBitRate(memlocation); + + /* load the sample into openal */ +#ifdef OUDE_OPENAL + alutLoadWAVMemory((char*)memlocation, &sampleformat, &data, &numberofsamples, &samplerate); // openal_2.12 +#else + alutLoadWAVMemory((signed char*)memlocation, &sampleformat, &data, &numberofsamples, &samplerate, &loop);// openal_2.14+ +#endif + /* put it in the buffer */ + alBufferData(m_buffers[buffer], sampleformat, data, numberofsamples, samplerate); + } + /* or from file? */ + else + { +#ifdef WIN32 + alutLoadWAVFile((signed char*)samplename.Ptr(), &sampleformat, &data, &numberofsamples, &samplerate, &loop); +#else + alutLoadWAV((char*)samplename.Ptr(), &data, + &sampleformat, &numberofsamples, + &samplerate, &frequency); +#endif + /* put it in the buffer */ + alBufferData(m_buffers[buffer], sampleformat, data, numberofsamples, samplerate); + } + + /* fill the waveslot with info */ + al_error = alGetError(); + if (al_error == AL_NO_ERROR && m_buffers[buffer]) + { + waveslot->SetData(data); + waveslot->SetSampleFormat(sampleformat); + waveslot->SetNumberOfChannels(numberofchannels); + waveslot->SetSampleRate(samplerate); + waveslot->SetBitRate(bitrate); + waveslot->SetNumberOfSamples(numberofsamples); + + /* if the loading succeeded, mark the waveslot */ + waveslot->SetLoaded(true); + } + else + { + /* or when it failed, free the waveslot */ + m_wavecache->RemoveSample(waveslot->GetSampleName(), waveslot->GetBuffer()); + waveslot = NULL; + } + + /* and free the original stuff (copy was made in openal) */ + alutUnloadWAV(sampleformat, data, numberofsamples, samplerate); + } + } + else + { + /* sample not supported, remove waveslot */ + m_wavecache->RemoveSample(waveslot->GetSampleName(), waveslot->GetBuffer()); + waveslot = NULL; + } + } + return waveslot; +} + + + +// listener's and general stuff ////////////////////////////////////////////////////// + + + +/* sets the global dopplervelocity */ +void SND_OpenALDevice::SetDopplerVelocity(MT_Scalar dopplervelocity) const +{ + alDopplerVelocity ((float)dopplervelocity); +} + + + +/* sets the global dopplerfactor */ +void SND_OpenALDevice::SetDopplerFactor(MT_Scalar dopplerfactor) const +{ + alDopplerFactor ((float)dopplerfactor); +} + + + +/* sets the global rolloff factor */ +void SND_OpenALDevice::SetListenerRollOffFactor(MT_Scalar rollofffactor) const +{ + // not implemented in openal +} + + + +void SND_OpenALDevice::NextFrame() const +{ + // not needed by openal +} + + + +// set the gain for the listener +void SND_OpenALDevice::SetListenerGain(float gain) const +{ + alListenerf (AL_GAIN, gain); +} + + + +void SND_OpenALDevice::InitListener() +{ + // initialize the listener with these values that won't change + // (as long as we can have only one listener) + // now we can superimpose all listeners on each other (for they + // have the same settings) + float lispos[3] = {0,0,0}; + float lisvel[3] = {0,0,0}; +#ifdef WIN32 + float lisori[6] = {0,1,0,0,0,1}; +#else + float lisori[6] = {0,0,1,0,-1,0}; +#endif + + alListenerfv(AL_POSITION, lispos); + alListenerfv(AL_VELOCITY, lisvel); + alListenerfv(AL_ORIENTATION, lisori); +} + + + +// source playstate stuff //////////////////////////////////////////////////////////// + + + +/* sets the buffer */ +void SND_OpenALDevice::SetObjectBuffer(int id, unsigned int buffer) +{ + alSourcei (m_sources[id], AL_BUFFER, m_buffers[buffer]); +} + + + +// check if the sound's still playing +int SND_OpenALDevice::GetPlayState(int id) +{ + int alstate = 0; + int result = 0; + + alGetSourceiv(m_sources[id], AL_SOURCE_STATE, &alstate); + + switch(alstate) + { + case AL_INITIAL: + { + result = SND_INITIAL; + break; + } + case AL_PLAYING: + { + result = SND_PLAYING; + break; + } + case AL_PAUSED: + { + result = SND_PAUSED; + break; + } + case AL_STOPPED: + { + result = SND_STOPPED; + break; + } + default: + result = SND_UNKNOWN; + } + + return result; +} + + + +// make the source play +void SND_OpenALDevice::PlayObject(int id) +{ + alSourcePlay(m_sources[id]); +} + + + +// make the source stop +void SND_OpenALDevice::StopObject(int id) const +{ + float obpos[3] = {0,0,0}; + float obvel[3] = {0,0,0}; + + alSourcefv(m_sources[id], AL_POSITION, obpos); + +#ifdef WIN32 + alSourcefv(m_sources[id], AL_VELOCITY, obvel); +#endif + + alSourcef(m_sources[id], AL_GAIN, 1.0); + alSourcef(m_sources[id], AL_PITCH, 1.0); + alSourcei(m_sources[id], AL_LOOPING, AL_FALSE); + alSourceStop(m_sources[id]); +} + + + +// stop all sources +void SND_OpenALDevice::StopAllObjects() +{ + alSourceStopv(NUM_SOURCES, m_sources); +} + + + +// pause the source +void SND_OpenALDevice::PauseObject(int id) const +{ + alSourcePause(m_sources[id]); +} + + + +// source properties stuff //////////////////////////////////////////////////////////// + + + +// give openal the object's pitch +void SND_OpenALDevice::SetObjectPitch(int id, MT_Scalar pitch) const +{ + alSourcef (m_sources[id], AL_PITCH, (float)pitch); +} + + + +// give openal the object's gain +void SND_OpenALDevice::SetObjectGain(int id, MT_Scalar gain) const +{ + alSourcef (m_sources[id], AL_GAIN, (float)gain); +} + + + +// give openal the object's looping +void SND_OpenALDevice::SetObjectLoop(int id, unsigned int loopmode) const +{ + if (loopmode == SND_LOOP_OFF) + { + //printf("%d - ", id); + alSourcei (m_sources[id], AL_LOOPING, AL_FALSE); + } + else + alSourcei (m_sources[id], AL_LOOPING, AL_TRUE); +} + + + +void SND_OpenALDevice::SetObjectMinGain(int id, MT_Scalar mingain) const +{ + alSourcef (m_sources[id], AL_MIN_GAIN, (float)mingain); +} + + + +void SND_OpenALDevice::SetObjectMaxGain(int id, MT_Scalar maxgain) const +{ + alSourcef (m_sources[id], AL_MAX_GAIN, (float)maxgain); +} + + + +void SND_OpenALDevice::SetObjectRollOffFactor(int id, MT_Scalar rollofffactor) const +{ + alSourcef (m_sources[id], AL_ROLLOFF_FACTOR, (float)rollofffactor); +} + + + +void SND_OpenALDevice::SetObjectReferenceDistance(int id, MT_Scalar referencedistance) const +{ + alSourcef (m_sources[id], AL_REFERENCE_DISTANCE, (float)referencedistance); +} + + + +// give openal the object's position +void SND_OpenALDevice::ObjectIs2D(int id) const +{ + float obpos[3] = {0,0,0}; + float obvel[3] = {0,0,0}; + + alSourcefv(m_sources[id], AL_POSITION, obpos); + alSourcefv(m_sources[id], AL_VELOCITY, obvel); +} + + + +void SND_OpenALDevice::SetObjectTransform(int id, + const MT_Vector3& position, + const MT_Vector3& velocity, + const MT_Matrix3x3& orientation, + const MT_Vector3& lisposition, + const MT_Scalar& rollofffactor) const +{ + float obpos[3]; + float obvel[3]; + + obpos[0] = (float)position[0] * (float)rollofffactor; //x (l/r) + obpos[1] = (float)position[1] * (float)rollofffactor; + obpos[2] = (float)position[2] * (float)rollofffactor; + + alSourcefv(m_sources[id], AL_POSITION, obpos); + +#ifdef WIN32 + velocity.getValue(obvel); + alSourcefv(m_sources[id], AL_VELOCITY, obvel); +#endif + +} diff --git a/intern/SoundSystem/openal/SND_OpenALDevice.h b/intern/SoundSystem/openal/SND_OpenALDevice.h new file mode 100644 index 00000000000..95940bacde2 --- /dev/null +++ b/intern/SoundSystem/openal/SND_OpenALDevice.h @@ -0,0 +1,102 @@ +/** + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ +#ifndef SND_OPENALDEVICE +#define SND_OPENALDEVICE + +#include "SND_AudioDevice.h" +#include "SoundDefines.h" + +class SND_OpenALDevice : public SND_AudioDevice +{ +public: + SND_OpenALDevice(); + ~SND_OpenALDevice(); + + SND_WaveSlot* LoadSample(const STR_String& samplename, + void* memlocation, + int size); + + void InitListener(); + void SetListenerGain(float gain) const; + void SetDopplerVelocity(MT_Scalar dopplervelocity) const; + void SetDopplerFactor(MT_Scalar dopplerfactor) const; + void SetListenerRollOffFactor(MT_Scalar rollofffactor) const; + + void MakeCurrent() const; + + void NextFrame() const; + + void SetObjectBuffer(int id, unsigned int buffer); + + int GetPlayState(int id); + void PlayObject(int id); + void StopObject(int id) const; + void StopAllObjects(); + void PauseObject(int id) const; + + void SetObjectLoop(int id, unsigned int loopmode) const; + void SetObjectLoopPoints(int id, unsigned int loopstart, unsigned int loopend) const {}; + void SetObjectPitch(int id, MT_Scalar pitch) const; + void SetObjectGain(int id, MT_Scalar gain) const; + void SetObjectMinGain(int id, MT_Scalar mingain) const; + void SetObjectMaxGain(int id, MT_Scalar maxgain) const; + void SetObjectRollOffFactor(int id, MT_Scalar rolloff) const; + void SetObjectReferenceDistance(int id, MT_Scalar distance) const; + + void SetObjectTransform(int id, + const MT_Vector3& position, + const MT_Vector3& velocity, + const MT_Matrix3x3& orientation, + const MT_Vector3& lisposition, + const MT_Scalar& rollofffactor) const; + void ObjectIs2D(int id) const; + + void PlayCD(int track) const {}; + void PauseCD(bool pause) const {}; + void StopCD() const {}; + void SetCDPlaymode(int playmode) const {}; + void SetCDGain(MT_Scalar gain) const {}; + + void StartUsingDSP() {}; + float* GetSpectrum() { return NULL; } + void StopUsingDSP() {}; + +private: + void* m_context; + + unsigned int m_buffers[NUM_BUFFERS]; + unsigned int m_sources[NUM_SOURCES]; + bool m_buffersinitialized; + bool m_sourcesinitialized; +}; + +#endif //SND_OPENALDEVICE diff --git a/intern/SoundSystem/openal/pthread_cancel.cpp b/intern/SoundSystem/openal/pthread_cancel.cpp new file mode 100644 index 00000000000..de05c742dea --- /dev/null +++ b/intern/SoundSystem/openal/pthread_cancel.cpp @@ -0,0 +1,65 @@ +/* $Id$ +/* + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + * FreeBSD 3.4 does not yet have pthread_cancel (3.5 and above do) + */ +#ifdef __FreeBSD__ + +#include <osreldate.h> + +#if (__FreeBSD_version < 350000) +#include <pthread.h> + +#define FD_READ 0x1 +#define _FD_LOCK(_fd,_type,_ts) _thread_fd_lock(_fd, _type, _ts) +#define _FD_UNLOCK(_fd,_type) _thread_fd_unlock(_fd, _type) + +int pthread_cancel(pthread_t pthread) { + pthread_exit(NULL); + return 0; +} + +long fpathconf(int fd, int name) +{ + long ret; + + if ((ret = _FD_LOCK(fd, FD_READ, NULL)) == 0) { + ret = _thread_sys_fpathconf(fd, name); + _FD_UNLOCK(fd, FD_READ); + } + return ret; +} + +#endif + +int pthread_atfork(void *a, void *b, void *c) { + return 0; +} + +#endif |