Audaspace: external audaspace library update.

1 files changed, 101 insertions, 85 deletions

diff --git a/source/blender/blenkernel/intern/sound.c b/source/blender/blenkernel/intern/sound.c
index 0eaae45c008..a7346c8af67 100644
--- a/source/blender/blenkernel/intern/sound.c
+++ b/source/blender/blenkernel/intern/sound.c
@@ -109,13 +109,13 @@ void BKE_sound_free(bSound *sound)
 
 #ifdef WITH_AUDASPACE
 	if (sound->handle) {
-		AUD_unload(sound->handle);
+		AUD_Sound_free(sound->handle);
 		sound->handle = NULL;
 		sound->playback_handle = NULL;
 	}
 
 	if (sound->cache) {
-		AUD_unload(sound->cache);
+		AUD_Sound_free(sound->cache);
 		sound->cache = NULL;
 	}
 
@@ -148,7 +148,7 @@ static void sound_sync_callback(void *data, int mode, float time)
 			else
 				BKE_sound_stop_scene(scene);
 			if (scene->playback_handle)
-				AUD_seek(scene->playback_handle, time);
+				AUD_Handle_setPosition(scene->playback_handle, time);
 		}
 		scene = scene->id.next;
 	}
@@ -180,6 +180,13 @@ void BKE_sound_init_once(void)
 	atexit(BKE_sound_exit_once);
 }
 
+static AUD_Device* sound_device;
+
+void* sound_get_device(void)
+{
+	return sound_device;
+}
+
 void BKE_sound_init(struct Main *bmain)
 {
 	AUD_DeviceSpecs specs;
@@ -223,8 +230,8 @@ void BKE_sound_init(struct Main *bmain)
 	if (specs.channels <= AUD_CHANNELS_INVALID)
 		specs.channels = AUD_CHANNELS_STEREO;
 
-	if (!AUD_init(device_name, "Blender", specs, buffersize))
-		AUD_init("Null", "Blender", specs, buffersize);
+	if (!(sound_device = AUD_init(device_name, specs, buffersize, "Blender")))
+		sound_device = AUD_init("Null", specs, buffersize, "Blender");
 
 	BKE_sound_init_main(bmain);
 }
@@ -240,12 +247,14 @@ void BKE_sound_init_main(struct Main *bmain)
 
 void BKE_sound_exit(void)
 {
-	AUD_exit();
+	AUD_exit(sound_device);
+	sound_device = NULL;
 }
 
 void BKE_sound_exit_once(void)
 {
-	AUD_exit();
+	AUD_exit(sound_device);
+	sound_device = NULL;
 	AUD_exitOnce();
 }
 
@@ -303,9 +312,9 @@ void BKE_sound_cache(bSound *sound)
 {
 	sound->flags |= SOUND_FLAGS_CACHING;
 	if (sound->cache)
-		AUD_unload(sound->cache);
+		AUD_Sound_free(sound->cache);
 
-	sound->cache = AUD_bufferSound(sound->handle);
+	sound->cache = AUD_Sound_cache(sound->handle);
 	if (sound->cache)
 		sound->playback_handle = sound->cache;
 	else
@@ -316,7 +325,7 @@ void BKE_sound_delete_cache(bSound *sound)
 {
 	sound->flags &= ~SOUND_FLAGS_CACHING;
 	if (sound->cache) {
-		AUD_unload(sound->cache);
+		AUD_Sound_free(sound->cache);
 		sound->cache = NULL;
 		sound->playback_handle = sound->handle;
 	}
@@ -326,12 +335,12 @@ void BKE_sound_load(struct Main *bmain, bSound *sound)
 {
 	if (sound) {
 		if (sound->cache) {
-			AUD_unload(sound->cache);
+			AUD_Sound_free(sound->cache);
 			sound->cache = NULL;
 		}
 
 		if (sound->handle) {
-			AUD_unload(sound->handle);
+			AUD_Sound_free(sound->handle);
 			sound->handle = NULL;
 			sound->playback_handle = NULL;
 		}
@@ -356,10 +365,10 @@ void BKE_sound_load(struct Main *bmain, bSound *sound)
 
 			/* but we need a packed file then */
 			if (pf)
-				sound->handle = AUD_loadBuffer((unsigned char *) pf->data, pf->size);
+				sound->handle = AUD_Sound_bufferFile((unsigned char *) pf->data, pf->size);
 			/* or else load it from disk */
 			else
-				sound->handle = AUD_load(fullpath);
+				sound->handle = AUD_Sound_file(fullpath);
 		}
 /* XXX unused currently */
 #if 0
@@ -376,13 +385,13 @@ void BKE_sound_load(struct Main *bmain, bSound *sound)
 	}
 #endif
 		if (sound->flags & SOUND_FLAGS_MONO) {
-			void *handle = AUD_monoSound(sound->handle);
-			AUD_unload(sound->handle);
+			void *handle = AUD_Sound_rechannel(sound->handle, AUD_CHANNELS_MONO);
+			AUD_Sound_free(sound->handle);
 			sound->handle = handle;
 		}
 
 		if (sound->flags & SOUND_FLAGS_CACHING) {
-			sound->cache = AUD_bufferSound(sound->handle);
+			sound->cache = AUD_Sound_cache(sound->handle);
 		}
 
 		if (sound->cache)
@@ -405,9 +414,10 @@ void BKE_sound_create_scene(struct Scene *scene)
 	if (scene->r.frs_sec_base == 0)
 		scene->r.frs_sec_base = 1;
 
-	scene->sound_scene = AUD_createSequencer(FPS, scene->audio.flag & AUDIO_MUTE);
-	AUD_updateSequencerData(scene->sound_scene, scene->audio.speed_of_sound,
-	                        scene->audio.doppler_factor, scene->audio.distance_model);
+	scene->sound_scene = AUD_Sequence_create(FPS, scene->audio.flag & AUDIO_MUTE);
+	AUD_Sequence_setSpeedOfSound(scene->sound_scene, scene->audio.speed_of_sound);
+	AUD_Sequence_setDopplerFactor(scene->sound_scene, scene->audio.doppler_factor);
+	AUD_Sequence_setDistanceModel(scene->sound_scene, scene->audio.distance_model);
 	scene->playback_handle = NULL;
 	scene->sound_scrub_handle = NULL;
 	scene->speaker_handles = NULL;
@@ -416,11 +426,11 @@ void BKE_sound_create_scene(struct Scene *scene)
 void BKE_sound_destroy_scene(struct Scene *scene)
 {
 	if (scene->playback_handle)
-		AUD_stop(scene->playback_handle);
+		AUD_Handle_stop(scene->playback_handle);
 	if (scene->sound_scrub_handle)
-		AUD_stop(scene->sound_scrub_handle);
+		AUD_Handle_stop(scene->sound_scrub_handle);
 	if (scene->sound_scene)
-		AUD_destroySequencer(scene->sound_scene);
+		AUD_Sequence_free(scene->sound_scene);
 	if (scene->speaker_handles)
 		AUD_destroySet(scene->speaker_handles);
 }
@@ -428,21 +438,22 @@ void BKE_sound_destroy_scene(struct Scene *scene)
 void BKE_sound_mute_scene(struct Scene *scene, int muted)
 {
 	if (scene->sound_scene)
-		AUD_setSequencerMuted(scene->sound_scene, muted);
+		AUD_Sequence_setMuted(scene->sound_scene, muted);
 }
 
 void BKE_sound_update_fps(struct Scene *scene)
 {
 	if (scene->sound_scene)
-		AUD_setSequencerFPS(scene->sound_scene, FPS);
+		AUD_Sequence_setFPS(scene->sound_scene, FPS);
 
 	BKE_sequencer_refresh_sound_length(scene);
 }
 
 void BKE_sound_update_scene_listener(struct Scene *scene)
 {
-	AUD_updateSequencerData(scene->sound_scene, scene->audio.speed_of_sound,
-	                        scene->audio.doppler_factor, scene->audio.distance_model);
+	AUD_Sequence_setSpeedOfSound(scene->sound_scene, scene->audio.speed_of_sound);
+	AUD_Sequence_setDopplerFactor(scene->sound_scene, scene->audio.doppler_factor);
+	AUD_Sequence_setDistanceModel(scene->sound_scene, scene->audio.distance_model);
 }
 
 void *BKE_sound_scene_add_scene_sound(struct Scene *scene, struct Sequence *sequence,
@@ -450,7 +461,7 @@ void *BKE_sound_scene_add_scene_sound(struct Scene *scene, struct Sequence *sequ
 {
 	if (scene != sequence->scene) {
 		const double fps = FPS;
-		return AUD_addSequence(scene->sound_scene, sequence->scene->sound_scene,
+		return AUD_Sequence_add(scene->sound_scene, sequence->scene->sound_scene,
 		                       startframe / fps, endframe / fps, frameskip / fps);
 	}
 	return NULL;
@@ -466,12 +477,12 @@ void *BKE_sound_scene_add_scene_sound_defaults(struct Scene *scene, struct Seque
 void *BKE_sound_add_scene_sound(struct Scene *scene, struct Sequence *sequence, int startframe, int endframe, int frameskip)
 {
 	const double fps = FPS;
-	void *handle = AUD_addSequence(scene->sound_scene, sequence->sound->playback_handle,
+	void *handle = AUD_Sequence_add(scene->sound_scene, sequence->sound->playback_handle,
 	                               startframe / fps, endframe / fps, frameskip / fps);
-	AUD_muteSequence(handle, (sequence->flag & SEQ_MUTE) != 0);
-	AUD_setSequenceAnimData(handle, AUD_AP_VOLUME, CFRA, &sequence->volume, 0);
-	AUD_setSequenceAnimData(handle, AUD_AP_PITCH, CFRA, &sequence->pitch, 0);
-	AUD_setSequenceAnimData(handle, AUD_AP_PANNING, CFRA, &sequence->pan, 0);
+	AUD_SequenceEntry_setMuted(handle, (sequence->flag & SEQ_MUTE) != 0);
+	AUD_SequenceEntry_setAnimationData(handle, AUD_AP_VOLUME, CFRA, &sequence->volume, 0);
+	AUD_SequenceEntry_setAnimationData(handle, AUD_AP_PITCH, CFRA, &sequence->pitch, 0);
+	AUD_SequenceEntry_setAnimationData(handle, AUD_AP_PANNING, CFRA, &sequence->pan, 0);
 	return handle;
 }
 
@@ -484,18 +495,18 @@ void *BKE_sound_add_scene_sound_defaults(struct Scene *scene, struct Sequence *s
 
 void BKE_sound_remove_scene_sound(struct Scene *scene, void *handle)
 {
-	AUD_removeSequence(scene->sound_scene, handle);
+	AUD_Sequence_remove(scene->sound_scene, handle);
 }
 
 void BKE_sound_mute_scene_sound(void *handle, char mute)
 {
-	AUD_muteSequence(handle, mute);
+	AUD_SequenceEntry_setMuted(handle, mute);
 }
 
 void BKE_sound_move_scene_sound(struct Scene *scene, void *handle, int startframe, int endframe, int frameskip)
 {
 	const double fps = FPS;
-	AUD_moveSequence(handle, startframe / fps, endframe / fps, frameskip / fps);
+	AUD_SequenceEntry_move(handle, startframe / fps, endframe / fps, frameskip / fps);
 }
 
 void BKE_sound_move_scene_sound_defaults(struct Scene *scene, struct Sequence *sequence)
@@ -509,7 +520,7 @@ void BKE_sound_move_scene_sound_defaults(struct Scene *scene, struct Sequence *s
 
 void BKE_sound_update_scene_sound(void *handle, bSound *sound)
 {
-	AUD_updateSequenceSound(handle, sound->playback_handle);
+	AUD_SequenceEntry_setSound(handle, sound->playback_handle);
 }
 
 void BKE_sound_set_cfra(int cfra)
@@ -519,23 +530,23 @@ void BKE_sound_set_cfra(int cfra)
 
 void BKE_sound_set_scene_volume(struct Scene *scene, float volume)
 {
-	AUD_setSequencerAnimData(scene->sound_scene, AUD_AP_VOLUME, CFRA, &volume,
+	AUD_Sequence_setAnimationData(scene->sound_scene, AUD_AP_VOLUME, CFRA, &volume,
 	                         (scene->audio.flag & AUDIO_VOLUME_ANIMATED) != 0);
 }
 
 void BKE_sound_set_scene_sound_volume(void *handle, float volume, char animated)
 {
-	AUD_setSequenceAnimData(handle, AUD_AP_VOLUME, sound_cfra, &volume, animated);
+	AUD_SequenceEntry_setAnimationData(handle, AUD_AP_VOLUME, sound_cfra, &volume, animated);
 }
 
 void BKE_sound_set_scene_sound_pitch(void *handle, float pitch, char animated)
 {
-	AUD_setSequenceAnimData(handle, AUD_AP_PITCH, sound_cfra, &pitch, animated);
+	AUD_SequenceEntry_setAnimationData(handle, AUD_AP_PITCH, sound_cfra, &pitch, animated);
 }
 
 void BKE_sound_set_scene_sound_pan(void *handle, float pan, char animated)
 {
-	AUD_setSequenceAnimData(handle, AUD_AP_PANNING, sound_cfra, &pan, animated);
+	AUD_SequenceEntry_setAnimationData(handle, AUD_AP_PANNING, sound_cfra, &pan, animated);
 }
 
 void BKE_sound_update_sequencer(struct Main *main, bSound *sound)
@@ -549,13 +560,18 @@ void BKE_sound_update_sequencer(struct Main *main, bSound *sound)
 
 static void sound_start_play_scene(struct Scene *scene)
 {
+	AUD_Specs specs;
+
 	if (scene->playback_handle)
-		AUD_stop(scene->playback_handle);
+		AUD_Handle_stop(scene->playback_handle);
+
+	specs.channels = AUD_Device_getChannels(sound_device);
+	specs.rate = AUD_Device_getRate(sound_device);
 
-	AUD_setSequencerDeviceSpecs(scene->sound_scene);
+	AUD_Sequence_setSpecs(scene->sound_scene, specs);
 
-	if ((scene->playback_handle = AUD_play(scene->sound_scene, 1)))
-		AUD_setLoop(scene->playback_handle, -1);
+	if ((scene->playback_handle = AUD_Device_play(sound_device, scene->sound_scene, 1)))
+		AUD_Handle_setLoopCount(scene->playback_handle, -1);
 }
 
 void BKE_sound_play_scene(struct Scene *scene)
@@ -563,34 +579,34 @@ void BKE_sound_play_scene(struct Scene *scene)
 	AUD_Status status;
 	const float cur_time = (float)((double)CFRA / FPS);
 
-	AUD_lock();
+	AUD_Device_lock(sound_device);
 
-	status = scene->playback_handle ? AUD_getStatus(scene->playback_handle) : AUD_STATUS_INVALID;
+	status = scene->playback_handle ? AUD_Handle_getStatus(scene->playback_handle) : AUD_STATUS_INVALID;
 
 	if (status == AUD_STATUS_INVALID) {
 		sound_start_play_scene(scene);
 
 		if (!scene->playback_handle) {
-			AUD_unlock();
+			AUD_Device_unlock(sound_device);
 			return;
 		}
 	}
 
 	if (status != AUD_STATUS_PLAYING) {
-		AUD_seek(scene->playback_handle, cur_time);
-		AUD_resume(scene->playback_handle);
+		AUD_Handle_setPosition(scene->playback_handle, cur_time);
+		AUD_Handle_resume(scene->playback_handle);
 	}
 
 	if (scene->audio.flag & AUDIO_SYNC)
 		AUD_playSynchronizer();
 
-	AUD_unlock();
+	AUD_Device_unlock(sound_device);
 }
 
 void BKE_sound_stop_scene(struct Scene *scene)
 {
 	if (scene->playback_handle) {
-		AUD_pause(scene->playback_handle);
+		AUD_Handle_pause(scene->playback_handle);
 
 		if (scene->audio.flag & AUDIO_SYNC)
 			AUD_stopSynchronizer();
@@ -606,19 +622,19 @@ void BKE_sound_seek_scene(struct Main *bmain, struct Scene *scene)
 	const float one_frame = (float)(1.0 / FPS);
 	const float cur_time = (float)((double)CFRA / FPS);
 
-	AUD_lock();
+	AUD_Device_lock(sound_device);
 
-	status = scene->playback_handle ? AUD_getStatus(scene->playback_handle) : AUD_STATUS_INVALID;
+	status = scene->playback_handle ? AUD_Handle_getStatus(scene->playback_handle) : AUD_STATUS_INVALID;
 
 	if (status == AUD_STATUS_INVALID) {
 		sound_start_play_scene(scene);
 
 		if (!scene->playback_handle) {
-			AUD_unlock();
+			AUD_Device_unlock(sound_device);
 			return;
 		}
 
-		AUD_pause(scene->playback_handle);
+		AUD_Handle_pause(scene->playback_handle);
 	}
 
 	animation_playing = 0;
@@ -630,20 +646,17 @@ void BKE_sound_seek_scene(struct Main *bmain, struct Scene *scene)
 	}
 
 	if (scene->audio.flag & AUDIO_SCRUB && !animation_playing) {
+		AUD_Handle_setPosition(scene->playback_handle, cur_time);
 		if (scene->audio.flag & AUDIO_SYNC) {
-			AUD_seek(scene->playback_handle, cur_time);
 			AUD_seekSynchronizer(scene->playback_handle, cur_time);
 		}
-		else {
-			AUD_seek(scene->playback_handle, cur_time);
-		}
-		AUD_resume(scene->playback_handle);
-		if (scene->sound_scrub_handle && AUD_getStatus(scene->sound_scrub_handle) != AUD_STATUS_INVALID) {
-			AUD_seek(scene->sound_scrub_handle, 0);
+		AUD_Handle_resume(scene->playback_handle);
+		if (scene->sound_scrub_handle && AUD_Handle_getStatus(scene->sound_scrub_handle) != AUD_STATUS_INVALID) {
+			AUD_Handle_setPosition(scene->sound_scrub_handle, 0);
 		}
 		else {
 			if (scene->sound_scrub_handle) {
-				AUD_stop(scene->sound_scrub_handle);
+				AUD_Handle_stop(scene->sound_scrub_handle);
 			}
 			scene->sound_scrub_handle = AUD_pauseAfter(scene->playback_handle, one_frame);
 		}
@@ -654,12 +667,12 @@ void BKE_sound_seek_scene(struct Main *bmain, struct Scene *scene)
 		}
 		else {
 			if (status == AUD_STATUS_PLAYING) {
-				AUD_seek(scene->playback_handle, cur_time);
+				AUD_Handle_setPosition(scene->playback_handle, cur_time);
 			}
 		}
 	}
 
-	AUD_unlock();
+	AUD_Device_unlock(sound_device);
 }
 
 float BKE_sound_sync_scene(struct Scene *scene)
@@ -668,7 +681,7 @@ float BKE_sound_sync_scene(struct Scene *scene)
 		if (scene->audio.flag & AUDIO_SYNC)
 			return AUD_getSynchronizerPosition(scene->playback_handle);
 		else
-			return AUD_getPosition(scene->playback_handle);
+			return AUD_Handle_getPosition(scene->playback_handle);
 	}
 	return NAN_FLT;
 }
@@ -762,38 +775,41 @@ void BKE_sound_update_scene(Main *bmain, struct Scene *scene)
 
 					if (AUD_removeSet(scene->speaker_handles, strip->speaker_handle)) {
 						if (speaker->sound) {
-							AUD_moveSequence(strip->speaker_handle, (double)strip->start / FPS, FLT_MAX, 0);
+							AUD_SequenceEntry_move(strip->speaker_handle, (double)strip->start / FPS, FLT_MAX, 0);
 						}
 						else {
-							AUD_removeSequence(scene->sound_scene, strip->speaker_handle);
+							AUD_Sequence_remove(scene->sound_scene, strip->speaker_handle);
 							strip->speaker_handle = NULL;
 						}
 					}
 					else {
 						if (speaker->sound) {
-							strip->speaker_handle = AUD_addSequence(scene->sound_scene,
+							strip->speaker_handle = AUD_Sequence_add(scene->sound_scene,
 							                                        speaker->sound->playback_handle,
 							                                        (double)strip->start / FPS, FLT_MAX, 0);
-							AUD_setRelativeSequence(strip->speaker_handle, 0);
+							AUD_SequenceEntry_setRelative(strip->speaker_handle, 0);
 						}
 					}
 
 					if (strip->speaker_handle) {
 						const bool mute = ((strip->flag & NLASTRIP_FLAG_MUTED) || (speaker->flag & SPK_MUTED));
 						AUD_addSet(new_set, strip->speaker_handle);
-						AUD_updateSequenceData(strip->speaker_handle, speaker->volume_max,
-						                       speaker->volume_min, speaker->distance_max,
-						                       speaker->distance_reference, speaker->attenuation,
-						                       speaker->cone_angle_outer, speaker->cone_angle_inner,
-						                       speaker->cone_volume_outer);
+						AUD_SequenceEntry_setVolumeMaximum(strip->speaker_handle, speaker->volume_max);
+						AUD_SequenceEntry_setVolumeMinimum(strip->speaker_handle, speaker->volume_min);
+						AUD_SequenceEntry_setDistanceMaximum(strip->speaker_handle, speaker->distance_max);
+						AUD_SequenceEntry_setDistanceReference(strip->speaker_handle, speaker->distance_reference);
+						AUD_SequenceEntry_setAttenuation(strip->speaker_handle, speaker->attenuation);
+						AUD_SequenceEntry_setConeAngleOuter(strip->speaker_handle, speaker->cone_angle_outer);
+						AUD_SequenceEntry_setConeAngleInner(strip->speaker_handle, speaker->cone_angle_inner);
+						AUD_SequenceEntry_setConeVolumeOuter(strip->speaker_handle, speaker->cone_volume_outer);
 
 						mat4_to_quat(quat, ob->obmat);
-						AUD_setSequenceAnimData(strip->speaker_handle, AUD_AP_LOCATION, CFRA, ob->obmat[3], 1);
-						AUD_setSequenceAnimData(strip->speaker_handle, AUD_AP_ORIENTATION, CFRA, quat, 1);
-						AUD_setSequenceAnimData(strip->speaker_handle, AUD_AP_VOLUME, CFRA, &speaker->volume, 1);
-						AUD_setSequenceAnimData(strip->speaker_handle, AUD_AP_PITCH, CFRA, &speaker->pitch, 1);
-						AUD_updateSequenceSound(strip->speaker_handle, speaker->sound->playback_handle);
-						AUD_muteSequence(strip->speaker_handle, mute);
+						AUD_SequenceEntry_setAnimationData(strip->speaker_handle, AUD_AP_LOCATION, CFRA, ob->obmat[3], 1);
+						AUD_SequenceEntry_setAnimationData(strip->speaker_handle, AUD_AP_ORIENTATION, CFRA, quat, 1);
+						AUD_SequenceEntry_setAnimationData(strip->speaker_handle, AUD_AP_VOLUME, CFRA, &speaker->volume, 1);
+						AUD_SequenceEntry_setAnimationData(strip->speaker_handle, AUD_AP_PITCH, CFRA, &speaker->pitch, 1);
+						AUD_SequenceEntry_setSound(strip->speaker_handle, speaker->sound->playback_handle);
+						AUD_SequenceEntry_setMuted(strip->speaker_handle, mute);
 					}
 				}
 			}
@@ -801,13 +817,13 @@ void BKE_sound_update_scene(Main *bmain, struct Scene *scene)
 	}
 
 	while ((handle = AUD_getSet(scene->speaker_handles))) {
-		AUD_removeSequence(scene->sound_scene, handle);
+		AUD_Sequence_remove(scene->sound_scene, handle);
 	}
 
 	if (scene->camera) {
 		mat4_to_quat(quat, scene->camera->obmat);
-		AUD_setSequencerAnimData(scene->sound_scene, AUD_AP_LOCATION, CFRA, scene->camera->obmat[3], 1);
-		AUD_setSequencerAnimData(scene->sound_scene, AUD_AP_ORIENTATION, CFRA, quat, 1);
+		AUD_Sequence_setAnimationData(scene->sound_scene, AUD_AP_LOCATION, CFRA, scene->camera->obmat[3], 1);
+		AUD_Sequence_setAnimationData(scene->sound_scene, AUD_AP_ORIENTATION, CFRA, quat, 1);
 	}
 
 	AUD_destroySet(scene->speaker_handles);