ClangFormat: apply to source, most of intern

Apply clang format as proposed in T53211.

For details on usage and instructions for migrating branches
without conflicts, see:

https://wiki.blender.org/wiki/Tools/ClangFormat

1 files changed, 785 insertions, 650 deletions

diff --git a/source/blender/blenkernel/intern/sound.c b/source/blender/blenkernel/intern/sound.c
index c909f00702d..383542fa335 100644
--- a/source/blender/blenkernel/intern/sound.c
+++ b/source/blender/blenkernel/intern/sound.c
@@ -63,86 +63,86 @@ static char **audio_device_names = NULL;
 
 bSound *BKE_sound_new_file(struct Main *bmain, const char *filepath)
 {
-	bSound *sound;
-	const char *path;
-	char str[FILE_MAX];
+  bSound *sound;
+  const char *path;
+  char str[FILE_MAX];
 
-	BLI_strncpy(str, filepath, sizeof(str));
+  BLI_strncpy(str, filepath, sizeof(str));
 
-	path = BKE_main_blendfile_path(bmain);
+  path = BKE_main_blendfile_path(bmain);
 
-	BLI_path_abs(str, path);
+  BLI_path_abs(str, path);
 
-	sound = BKE_libblock_alloc(bmain, ID_SO, BLI_path_basename(filepath), 0);
-	BLI_strncpy(sound->name, filepath, FILE_MAX);
-	/* sound->type = SOUND_TYPE_FILE; */ /* XXX unused currently */
+  sound = BKE_libblock_alloc(bmain, ID_SO, BLI_path_basename(filepath), 0);
+  BLI_strncpy(sound->name, filepath, FILE_MAX);
+  /* sound->type = SOUND_TYPE_FILE; */ /* XXX unused currently */
 
-	BKE_sound_load(bmain, sound);
+  BKE_sound_load(bmain, sound);
 
-	return sound;
+  return sound;
 }
 
 bSound *BKE_sound_new_file_exists_ex(struct Main *bmain, const char *filepath, bool *r_exists)
 {
-	bSound *sound;
-	char str[FILE_MAX], strtest[FILE_MAX];
-
-	BLI_strncpy(str, filepath, sizeof(str));
-	BLI_path_abs(str, BKE_main_blendfile_path(bmain));
-
-	/* first search an identical filepath */
-	for (sound = bmain->sounds.first; sound; sound = sound->id.next) {
-		BLI_strncpy(strtest, sound->name, sizeof(sound->name));
-		BLI_path_abs(strtest, ID_BLEND_PATH(bmain, &sound->id));
-
-		if (BLI_path_cmp(strtest, str) == 0) {
-			id_us_plus(&sound->id);  /* officially should not, it doesn't link here! */
-			if (r_exists)
-				*r_exists = true;
-			return sound;
-		}
-	}
-
-	if (r_exists)
-		*r_exists = false;
-	return BKE_sound_new_file(bmain, filepath);
+  bSound *sound;
+  char str[FILE_MAX], strtest[FILE_MAX];
+
+  BLI_strncpy(str, filepath, sizeof(str));
+  BLI_path_abs(str, BKE_main_blendfile_path(bmain));
+
+  /* first search an identical filepath */
+  for (sound = bmain->sounds.first; sound; sound = sound->id.next) {
+    BLI_strncpy(strtest, sound->name, sizeof(sound->name));
+    BLI_path_abs(strtest, ID_BLEND_PATH(bmain, &sound->id));
+
+    if (BLI_path_cmp(strtest, str) == 0) {
+      id_us_plus(&sound->id); /* officially should not, it doesn't link here! */
+      if (r_exists)
+        *r_exists = true;
+      return sound;
+    }
+  }
+
+  if (r_exists)
+    *r_exists = false;
+  return BKE_sound_new_file(bmain, filepath);
 }
 
 bSound *BKE_sound_new_file_exists(struct Main *bmain, const char *filepath)
 {
-	return BKE_sound_new_file_exists_ex(bmain, filepath, NULL);
+  return BKE_sound_new_file_exists_ex(bmain, filepath, NULL);
 }
 
 /** Free (or release) any data used by this sound (does not free the sound itself). */
 void BKE_sound_free(bSound *sound)
 {
-	/* No animdata here. */
+  /* No animdata here. */
 
-	if (sound->packedfile) {
-		freePackedFile(sound->packedfile);
-		sound->packedfile = NULL;
-	}
+  if (sound->packedfile) {
+    freePackedFile(sound->packedfile);
+    sound->packedfile = NULL;
+  }
 
 #ifdef WITH_AUDASPACE
-	if (sound->handle) {
-		AUD_Sound_free(sound->handle);
-		sound->handle = NULL;
-		sound->playback_handle = NULL;
-	}
-
-	if (sound->cache) {
-		AUD_Sound_free(sound->cache);
-		sound->cache = NULL;
-	}
-
-	BKE_sound_free_waveform(sound);
-
-#endif  /* WITH_AUDASPACE */
-	if (sound->spinlock) {
-		BLI_spin_end(sound->spinlock);
-		MEM_freeN(sound->spinlock);
-		sound->spinlock = NULL;
-	}
+  if (sound->handle) {
+    AUD_Sound_free(sound->handle);
+    sound->handle = NULL;
+    sound->playback_handle = NULL;
+  }
+
+  if (sound->cache) {
+    AUD_Sound_free(sound->cache);
+    sound->cache = NULL;
+  }
+
+  BKE_sound_free_waveform(sound);
+
+#endif /* WITH_AUDASPACE */
+  if (sound->spinlock) {
+    BLI_spin_end(sound->spinlock);
+    MEM_freeN(sound->spinlock);
+    sound->spinlock = NULL;
+  }
 }
 
 /**
@@ -153,833 +153,968 @@ void BKE_sound_free(bSound *sound)
  *
  * \param flag: Copying options (see BKE_library.h's LIB_ID_COPY_... flags for more).
  */
-void BKE_sound_copy_data(Main *bmain, bSound *sound_dst, const bSound *UNUSED(sound_src), const int UNUSED(flag))
+void BKE_sound_copy_data(Main *bmain,
+                         bSound *sound_dst,
+                         const bSound *UNUSED(sound_src),
+                         const int UNUSED(flag))
 {
-	sound_dst->handle = NULL;
-	sound_dst->cache = NULL;
-	sound_dst->waveform = NULL;
-	sound_dst->playback_handle = NULL;
-	sound_dst->spinlock = NULL;  /* Think this is OK? Otherwise, easy to create new spinlock here... */
-
-	/* Just to be sure, should not have any value actually after reading time. */
-	sound_dst->ipo = NULL;
-	sound_dst->newpackedfile = NULL;
-
-	if (sound_dst->packedfile) {
-		sound_dst->packedfile = dupPackedFile(sound_dst->packedfile);
-	}
-
-	/* Initialize whole runtime (audaspace) stuff. */
-	BKE_sound_load(bmain, sound_dst);
+  sound_dst->handle = NULL;
+  sound_dst->cache = NULL;
+  sound_dst->waveform = NULL;
+  sound_dst->playback_handle = NULL;
+  sound_dst->spinlock =
+      NULL; /* Think this is OK? Otherwise, easy to create new spinlock here... */
+
+  /* Just to be sure, should not have any value actually after reading time. */
+  sound_dst->ipo = NULL;
+  sound_dst->newpackedfile = NULL;
+
+  if (sound_dst->packedfile) {
+    sound_dst->packedfile = dupPackedFile(sound_dst->packedfile);
+  }
+
+  /* Initialize whole runtime (audaspace) stuff. */
+  BKE_sound_load(bmain, sound_dst);
 }
 
 void BKE_sound_make_local(Main *bmain, bSound *sound, const bool lib_local)
 {
-	BKE_id_make_local_generic(bmain, &sound->id, true, lib_local);
+  BKE_id_make_local_generic(bmain, &sound->id, true, lib_local);
 }
 
 #ifdef WITH_AUDASPACE
 
 static const char *force_device = NULL;
 
-#ifdef WITH_JACK
+#  ifdef WITH_JACK
 static void sound_sync_callback(void *data, int mode, float time)
 {
-	// Ugly: Blender doesn't like it when the animation is played back during rendering
-	if (G.is_rendering)
-		return;
-
-	struct Main *bmain = (struct Main *)data;
-	struct Scene *scene;
-
-	scene = bmain->scenes.first;
-	while (scene) {
-		if (scene->audio.flag & AUDIO_SYNC) {
-			if (mode)
-				BKE_sound_play_scene(scene);
-			else
-				BKE_sound_stop_scene(scene);
-			if (scene->playback_handle)
-				AUD_Handle_setPosition(scene->playback_handle, time);
-		}
-		scene = scene->id.next;
-	}
+  // Ugly: Blender doesn't like it when the animation is played back during rendering
+  if (G.is_rendering)
+    return;
+
+  struct Main *bmain = (struct Main *)data;
+  struct Scene *scene;
+
+  scene = bmain->scenes.first;
+  while (scene) {
+    if (scene->audio.flag & AUDIO_SYNC) {
+      if (mode)
+        BKE_sound_play_scene(scene);
+      else
+        BKE_sound_stop_scene(scene);
+      if (scene->playback_handle)
+        AUD_Handle_setPosition(scene->playback_handle, time);
+    }
+    scene = scene->id.next;
+  }
 }
-#endif
+#  endif
 
 void BKE_sound_force_device(const char *device)
 {
-	force_device = device;
+  force_device = device;
 }
 
 void BKE_sound_init_once(void)
 {
-	AUD_initOnce();
-	atexit(BKE_sound_exit_once);
+  AUD_initOnce();
+  atexit(BKE_sound_exit_once);
 }
 
 static AUD_Device *sound_device = NULL;
 
 void *BKE_sound_get_device(void)
 {
-	return sound_device;
+  return sound_device;
 }
 
 void BKE_sound_init(struct Main *bmain)
 {
-	/* Make sure no instance of the sound system is running, otherwise we get leaks. */
-	BKE_sound_exit();
-
-	AUD_DeviceSpecs specs;
-	int device, buffersize;
-	const char *device_name;
-
-	device = U.audiodevice;
-	buffersize = U.mixbufsize;
-	specs.channels = U.audiochannels;
-	specs.format = U.audioformat;
-	specs.rate = U.audiorate;
-
-	if (force_device == NULL) {
-		int i;
-		char **names = BKE_sound_get_device_names();
-		device_name = names[0];
-
-		/* make sure device is within the bounds of the array */
-		for (i = 0; names[i]; i++) {
-			if (i == device) {
-				device_name = names[i];
-			}
-		}
-	}
-	else
-		device_name = force_device;
-
-	if (buffersize < 128)
-		buffersize = 1024;
-
-	if (specs.rate < AUD_RATE_8000)
-		specs.rate = AUD_RATE_48000;
-
-	if (specs.format <= AUD_FORMAT_INVALID)
-		specs.format = AUD_FORMAT_S16;
-
-	if (specs.channels <= AUD_CHANNELS_INVALID)
-		specs.channels = AUD_CHANNELS_STEREO;
-
-	if (!(sound_device = AUD_init(device_name, specs, buffersize, "Blender")))
-		sound_device = AUD_init("Null", specs, buffersize, "Blender");
-
-	BKE_sound_init_main(bmain);
+  /* Make sure no instance of the sound system is running, otherwise we get leaks. */
+  BKE_sound_exit();
+
+  AUD_DeviceSpecs specs;
+  int device, buffersize;
+  const char *device_name;
+
+  device = U.audiodevice;
+  buffersize = U.mixbufsize;
+  specs.channels = U.audiochannels;
+  specs.format = U.audioformat;
+  specs.rate = U.audiorate;
+
+  if (force_device == NULL) {
+    int i;
+    char **names = BKE_sound_get_device_names();
+    device_name = names[0];
+
+    /* make sure device is within the bounds of the array */
+    for (i = 0; names[i]; i++) {
+      if (i == device) {
+        device_name = names[i];
+      }
+    }
+  }
+  else
+    device_name = force_device;
+
+  if (buffersize < 128)
+    buffersize = 1024;
+
+  if (specs.rate < AUD_RATE_8000)
+    specs.rate = AUD_RATE_48000;
+
+  if (specs.format <= AUD_FORMAT_INVALID)
+    specs.format = AUD_FORMAT_S16;
+
+  if (specs.channels <= AUD_CHANNELS_INVALID)
+    specs.channels = AUD_CHANNELS_STEREO;
+
+  if (!(sound_device = AUD_init(device_name, specs, buffersize, "Blender")))
+    sound_device = AUD_init("Null", specs, buffersize, "Blender");
+
+  BKE_sound_init_main(bmain);
 }
 
 void BKE_sound_init_main(struct Main *bmain)
 {
-#ifdef WITH_JACK
-	if (sound_device)
-		AUD_setSynchronizerCallback(sound_sync_callback, bmain);
-#else
-	(void)bmain; /* unused */
-#endif
+#  ifdef WITH_JACK
+  if (sound_device)
+    AUD_setSynchronizerCallback(sound_sync_callback, bmain);
+#  else
+  (void)bmain; /* unused */
+#  endif
 }
 
 void BKE_sound_exit(void)
 {
-	AUD_exit(sound_device);
-	sound_device = NULL;
+  AUD_exit(sound_device);
+  sound_device = NULL;
 }
 
 void BKE_sound_exit_once(void)
 {
-	AUD_exit(sound_device);
-	sound_device = NULL;
-	AUD_exitOnce();
-
-	if (audio_device_names != NULL) {
-		int i;
-		for (i = 0; audio_device_names[i]; i++) {
-			free(audio_device_names[i]);
-		}
-		free(audio_device_names);
-		audio_device_names = NULL;
-	}
+  AUD_exit(sound_device);
+  sound_device = NULL;
+  AUD_exitOnce();
+
+  if (audio_device_names != NULL) {
+    int i;
+    for (i = 0; audio_device_names[i]; i++) {
+      free(audio_device_names[i]);
+    }
+    free(audio_device_names);
+    audio_device_names = NULL;
+  }
 }
 
 /* XXX unused currently */
-#if 0
+#  if 0
 bSound *BKE_sound_new_buffer(struct Main *bmain, bSound *source)
 {
-	bSound *sound = NULL;
+  bSound *sound = NULL;
 
-	char name[MAX_ID_NAME + 5];
-	strcpy(name, "buf_");
-	strcpy(name + 4, source->id.name);
+  char name[MAX_ID_NAME + 5];
+  strcpy(name, "buf_");
+  strcpy(name + 4, source->id.name);
 
-	sound = BKE_libblock_alloc(bmain, ID_SO, name);
+  sound = BKE_libblock_alloc(bmain, ID_SO, name);
 
-	sound->child_sound = source;
-	sound->type = SOUND_TYPE_BUFFER;
+  sound->child_sound = source;
+  sound->type = SOUND_TYPE_BUFFER;
 
-	sound_load(bmain, sound);
+  sound_load(bmain, sound);
 
-	return sound;
+  return sound;
 }
 
 bSound *BKE_sound_new_limiter(struct Main *bmain, bSound *source, float start, float end)
 {
-	bSound *sound = NULL;
+  bSound *sound = NULL;
 
-	char name[MAX_ID_NAME + 5];
-	strcpy(name, "lim_");
-	strcpy(name + 4, source->id.name);
+  char name[MAX_ID_NAME + 5];
+  strcpy(name, "lim_");
+  strcpy(name + 4, source->id.name);
 
-	sound = BKE_libblock_alloc(bmain, ID_SO, name);
+  sound = BKE_libblock_alloc(bmain, ID_SO, name);
 
-	sound->child_sound = source;
-	sound->start = start;
-	sound->end = end;
-	sound->type = SOUND_TYPE_LIMITER;
+  sound->child_sound = source;
+  sound->start = start;
+  sound->end = end;
+  sound->type = SOUND_TYPE_LIMITER;
 
-	sound_load(bmain, sound);
+  sound_load(bmain, sound);
 
-	return sound;
+  return sound;
 }
-#endif
+#  endif
 
 void BKE_sound_cache(bSound *sound)
 {
-	sound->flags |= SOUND_FLAGS_CACHING;
-	if (sound->cache)
-		AUD_Sound_free(sound->cache);
-
-	sound->cache = AUD_Sound_cache(sound->handle);
-	if (sound->cache)
-		sound->playback_handle = sound->cache;
-	else
-		sound->playback_handle = sound->handle;
+  sound->flags |= SOUND_FLAGS_CACHING;
+  if (sound->cache)
+    AUD_Sound_free(sound->cache);
+
+  sound->cache = AUD_Sound_cache(sound->handle);
+  if (sound->cache)
+    sound->playback_handle = sound->cache;
+  else
+    sound->playback_handle = sound->handle;
 }
 
 void BKE_sound_delete_cache(bSound *sound)
 {
-	sound->flags &= ~SOUND_FLAGS_CACHING;
-	if (sound->cache) {
-		AUD_Sound_free(sound->cache);
-		sound->cache = NULL;
-		sound->playback_handle = sound->handle;
-	}
+  sound->flags &= ~SOUND_FLAGS_CACHING;
+  if (sound->cache) {
+    AUD_Sound_free(sound->cache);
+    sound->cache = NULL;
+    sound->playback_handle = sound->handle;
+  }
 }
 
 void BKE_sound_load(struct Main *bmain, bSound *sound)
 {
-	if (sound) {
-		if (sound->cache) {
-			AUD_Sound_free(sound->cache);
-			sound->cache = NULL;
-		}
+  if (sound) {
+    if (sound->cache) {
+      AUD_Sound_free(sound->cache);
+      sound->cache = NULL;
+    }
 
-		if (sound->handle) {
-			AUD_Sound_free(sound->handle);
-			sound->handle = NULL;
-			sound->playback_handle = NULL;
-		}
+    if (sound->handle) {
+      AUD_Sound_free(sound->handle);
+      sound->handle = NULL;
+      sound->playback_handle = NULL;
+    }
 
-		BKE_sound_free_waveform(sound);
+    BKE_sound_free_waveform(sound);
 
 /* XXX unused currently */
-#if 0
-		switch (sound->type)
-		{
-			case SOUND_TYPE_FILE:
-#endif
-		{
-			char fullpath[FILE_MAX];
-
-			/* load sound */
-			PackedFile *pf = sound->packedfile;
-
-			/* don't modify soundact->sound->name, only change a copy */
-			BLI_strncpy(fullpath, sound->name, sizeof(fullpath));
-			BLI_path_abs(fullpath, ID_BLEND_PATH(bmain, &sound->id));
-
-			/* but we need a packed file then */
-			if (pf)
-				sound->handle = AUD_Sound_bufferFile((unsigned char *) pf->data, pf->size);
-			/* or else load it from disk */
-			else
-				sound->handle = AUD_Sound_file(fullpath);
-		}
+#  if 0
+    switch (sound->type)
+    {
+      case SOUND_TYPE_FILE:
+#  endif
+    {
+      char fullpath[FILE_MAX];
+
+      /* load sound */
+      PackedFile *pf = sound->packedfile;
+
+      /* don't modify soundact->sound->name, only change a copy */
+      BLI_strncpy(fullpath, sound->name, sizeof(fullpath));
+      BLI_path_abs(fullpath, ID_BLEND_PATH(bmain, &sound->id));
+
+      /* but we need a packed file then */
+      if (pf)
+        sound->handle = AUD_Sound_bufferFile((unsigned char *)pf->data, pf->size);
+      /* or else load it from disk */
+      else
+        sound->handle = AUD_Sound_file(fullpath);
+    }
 /* XXX unused currently */
-#if 0
-			break;
-		}
-		case SOUND_TYPE_BUFFER:
-			if (sound->child_sound && sound->child_sound->handle)
-				sound->handle = AUD_bufferSound(sound->child_sound->handle);
-			break;
-		case SOUND_TYPE_LIMITER:
-			if (sound->child_sound && sound->child_sound->handle)
-				sound->handle = AUD_limitSound(sound->child_sound, sound->start, sound->end);
-			break;
-	}
-#endif
-		if (sound->flags & SOUND_FLAGS_MONO) {
-			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_Sound_cache(sound->handle);
-		}
-
-		if (sound->cache)
-			sound->playback_handle = sound->cache;
-		else
-			sound->playback_handle = sound->handle;
-
-		BKE_sound_update_sequencer(bmain, sound);
-	}
+#  if 0
+      break;
+    }
+    case SOUND_TYPE_BUFFER:
+      if (sound->child_sound && sound->child_sound->handle)
+        sound->handle = AUD_bufferSound(sound->child_sound->handle);
+      break;
+    case SOUND_TYPE_LIMITER:
+      if (sound->child_sound && sound->child_sound->handle)
+        sound->handle = AUD_limitSound(sound->child_sound, sound->start, sound->end);
+      break;
+  }
+#  endif
+    if (sound->flags & SOUND_FLAGS_MONO) {
+      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_Sound_cache(sound->handle);
+    }
+
+    if (sound->cache)
+      sound->playback_handle = sound->cache;
+    else
+      sound->playback_handle = sound->handle;
+
+    BKE_sound_update_sequencer(bmain, sound);
+  }
 }
 
 AUD_Device *BKE_sound_mixdown(struct Scene *scene, AUD_DeviceSpecs specs, int start, float volume)
 {
-	return AUD_openMixdownDevice(specs, scene->sound_scene, volume, start / FPS);
+  return AUD_openMixdownDevice(specs, scene->sound_scene, volume, start / FPS);
 }
 
 void BKE_sound_create_scene(struct Scene *scene)
 {
-	/* should be done in version patch, but this gets called before */
-	if (scene->r.frs_sec_base == 0)
-		scene->r.frs_sec_base = 1;
-
-	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;
+  /* should be done in version patch, but this gets called before */
+  if (scene->r.frs_sec_base == 0)
+    scene->r.frs_sec_base = 1;
+
+  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;
 }
 
 void BKE_sound_destroy_scene(struct Scene *scene)
 {
-	if (scene->playback_handle)
-		AUD_Handle_stop(scene->playback_handle);
-	if (scene->sound_scrub_handle)
-		AUD_Handle_stop(scene->sound_scrub_handle);
-	if (scene->sound_scene)
-		AUD_Sequence_free(scene->sound_scene);
-	if (scene->speaker_handles)
-		AUD_destroySet(scene->speaker_handles);
+  if (scene->playback_handle)
+    AUD_Handle_stop(scene->playback_handle);
+  if (scene->sound_scrub_handle)
+    AUD_Handle_stop(scene->sound_scrub_handle);
+  if (scene->sound_scene)
+    AUD_Sequence_free(scene->sound_scene);
+  if (scene->speaker_handles)
+    AUD_destroySet(scene->speaker_handles);
 }
 
 void BKE_sound_reset_scene_specs(struct Scene *scene)
 {
-	AUD_Specs specs;
+  AUD_Specs specs;
 
-	specs.channels = AUD_Device_getChannels(sound_device);
-	specs.rate = AUD_Device_getRate(sound_device);
+  specs.channels = AUD_Device_getChannels(sound_device);
+  specs.rate = AUD_Device_getRate(sound_device);
 
-	AUD_Sequence_setSpecs(scene->sound_scene, specs);
+  AUD_Sequence_setSpecs(scene->sound_scene, specs);
 }
 
 void BKE_sound_mute_scene(struct Scene *scene, int muted)
 {
-	if (scene->sound_scene)
-		AUD_Sequence_setMuted(scene->sound_scene, muted);
+  if (scene->sound_scene)
+    AUD_Sequence_setMuted(scene->sound_scene, muted);
 }
 
 void BKE_sound_update_fps(struct Scene *scene)
 {
-	if (scene->sound_scene)
-		AUD_Sequence_setFPS(scene->sound_scene, FPS);
+  if (scene->sound_scene)
+    AUD_Sequence_setFPS(scene->sound_scene, FPS);
 
-	BKE_sequencer_refresh_sound_length(scene);
+  BKE_sequencer_refresh_sound_length(scene);
 }
 
 void BKE_sound_update_scene_listener(struct Scene *scene)
 {
-	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);
+  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,
-                                  int startframe, int endframe, int frameskip)
+void *BKE_sound_scene_add_scene_sound(
+    struct Scene *scene, struct Sequence *sequence, int startframe, int endframe, int frameskip)
 {
-	if (sequence->scene && scene != sequence->scene) {
-		const double fps = FPS;
-		return AUD_Sequence_add(scene->sound_scene, sequence->scene->sound_scene,
-		                       startframe / fps, endframe / fps, frameskip / fps);
-	}
-	return NULL;
+  if (sequence->scene && scene != sequence->scene) {
+    const double fps = FPS;
+    return AUD_Sequence_add(scene->sound_scene,
+                            sequence->scene->sound_scene,
+                            startframe / fps,
+                            endframe / fps,
+                            frameskip / fps);
+  }
+  return NULL;
 }
 
 void *BKE_sound_scene_add_scene_sound_defaults(struct Scene *scene, struct Sequence *sequence)
 {
-	return BKE_sound_scene_add_scene_sound(scene, sequence,
-	                                   sequence->startdisp, sequence->enddisp,
-	                                   sequence->startofs + sequence->anim_startofs);
+  return BKE_sound_scene_add_scene_sound(scene,
+                                         sequence,
+                                         sequence->startdisp,
+                                         sequence->enddisp,
+                                         sequence->startofs + sequence->anim_startofs);
 }
 
-void *BKE_sound_add_scene_sound(struct Scene *scene, struct Sequence *sequence, int startframe, int endframe, int frameskip)
+void *BKE_sound_add_scene_sound(
+    struct Scene *scene, struct Sequence *sequence, int startframe, int endframe, int frameskip)
 {
-	/* Happens when sequence's sound datablock was removed. */
-	if (sequence->sound == NULL) {
-		return NULL;
-	}
-	const double fps = FPS;
-	void *handle = AUD_Sequence_add(scene->sound_scene, sequence->sound->playback_handle,
-	                               startframe / fps, endframe / fps, frameskip / fps);
-	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;
+  /* Happens when sequence's sound datablock was removed. */
+  if (sequence->sound == NULL) {
+    return NULL;
+  }
+  const double fps = FPS;
+  void *handle = AUD_Sequence_add(scene->sound_scene,
+                                  sequence->sound->playback_handle,
+                                  startframe / fps,
+                                  endframe / fps,
+                                  frameskip / fps);
+  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;
 }
 
 void *BKE_sound_add_scene_sound_defaults(struct Scene *scene, struct Sequence *sequence)
 {
-	return BKE_sound_add_scene_sound(scene, sequence,
-	                                 sequence->startdisp, sequence->enddisp,
-	                                 sequence->startofs + sequence->anim_startofs);
+  return BKE_sound_add_scene_sound(scene,
+                                   sequence,
+                                   sequence->startdisp,
+                                   sequence->enddisp,
+                                   sequence->startofs + sequence->anim_startofs);
 }
 
 void BKE_sound_remove_scene_sound(struct Scene *scene, void *handle)
 {
-	AUD_Sequence_remove(scene->sound_scene, handle);
+  AUD_Sequence_remove(scene->sound_scene, handle);
 }
 
 void BKE_sound_mute_scene_sound(void *handle, char mute)
 {
-	AUD_SequenceEntry_setMuted(handle, mute);
+  AUD_SequenceEntry_setMuted(handle, mute);
 }
 
-void BKE_sound_move_scene_sound(struct Scene *scene, void *handle, int startframe, int endframe, int frameskip)
+void BKE_sound_move_scene_sound(
+    struct Scene *scene, void *handle, int startframe, int endframe, int frameskip)
 {
-	const double fps = FPS;
-	AUD_SequenceEntry_move(handle, startframe / fps, endframe / fps, frameskip / fps);
+  const double fps = FPS;
+  AUD_SequenceEntry_move(handle, startframe / fps, endframe / fps, frameskip / fps);
 }
 
 void BKE_sound_move_scene_sound_defaults(struct Scene *scene, struct Sequence *sequence)
 {
-	if (sequence->scene_sound) {
-		BKE_sound_move_scene_sound(scene, sequence->scene_sound,
-		                       sequence->startdisp, sequence->enddisp,
-		                       sequence->startofs + sequence->anim_startofs);
-	}
+  if (sequence->scene_sound) {
+    BKE_sound_move_scene_sound(scene,
+                               sequence->scene_sound,
+                               sequence->startdisp,
+                               sequence->enddisp,
+                               sequence->startofs + sequence->anim_startofs);
+  }
 }
 
 void BKE_sound_update_scene_sound(void *handle, bSound *sound)
 {
-	AUD_SequenceEntry_setSound(handle, sound->playback_handle);
+  AUD_SequenceEntry_setSound(handle, sound->playback_handle);
 }
 
 void BKE_sound_set_cfra(int cfra)
 {
-	sound_cfra = cfra;
+  sound_cfra = cfra;
 }
 
 void BKE_sound_set_scene_volume(struct Scene *scene, float volume)
 {
-	AUD_Sequence_setAnimationData(scene->sound_scene, AUD_AP_VOLUME, CFRA, &volume,
-	                         (scene->audio.flag & AUDIO_VOLUME_ANIMATED) != 0);
+  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_SequenceEntry_setAnimationData(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_SequenceEntry_setAnimationData(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)
 {
-	printf("%s\n", __func__);
-	AUD_SequenceEntry_setAnimationData(handle, AUD_AP_PANNING, sound_cfra, &pan, animated);
+  printf("%s\n", __func__);
+  AUD_SequenceEntry_setAnimationData(handle, AUD_AP_PANNING, sound_cfra, &pan, animated);
 }
 
 void BKE_sound_update_sequencer(struct Main *main, bSound *sound)
 {
-	struct Scene *scene;
+  struct Scene *scene;
 
-	for (scene = main->scenes.first; scene; scene = scene->id.next) {
-		BKE_sequencer_update_sound(scene, sound);
-	}
+  for (scene = main->scenes.first; scene; scene = scene->id.next) {
+    BKE_sequencer_update_sound(scene, sound);
+  }
 }
 
 static void sound_start_play_scene(struct Scene *scene)
 {
-	if (scene->playback_handle)
-		AUD_Handle_stop(scene->playback_handle);
+  if (scene->playback_handle)
+    AUD_Handle_stop(scene->playback_handle);
 
-	BKE_sound_reset_scene_specs(scene);
+  BKE_sound_reset_scene_specs(scene);
 
-	if ((scene->playback_handle = AUD_Device_play(sound_device, scene->sound_scene, 1)))
-		AUD_Handle_setLoopCount(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)
 {
-	AUD_Status status;
-	const float cur_time = (float)((double)CFRA / FPS);
+  AUD_Status status;
+  const float cur_time = (float)((double)CFRA / FPS);
 
-	AUD_Device_lock(sound_device);
+  AUD_Device_lock(sound_device);
 
-	status = scene->playback_handle ? AUD_Handle_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 (status == AUD_STATUS_INVALID) {
+    sound_start_play_scene(scene);
 
-		if (!scene->playback_handle) {
-			AUD_Device_unlock(sound_device);
-			return;
-		}
-	}
+    if (!scene->playback_handle) {
+      AUD_Device_unlock(sound_device);
+      return;
+    }
+  }
 
-	if (status != AUD_STATUS_PLAYING) {
-		AUD_Handle_setPosition(scene->playback_handle, cur_time);
-		AUD_Handle_resume(scene->playback_handle);
-	}
+  if (status != AUD_STATUS_PLAYING) {
+    AUD_Handle_setPosition(scene->playback_handle, cur_time);
+    AUD_Handle_resume(scene->playback_handle);
+  }
 
-	if (scene->audio.flag & AUDIO_SYNC)
-		AUD_playSynchronizer();
+  if (scene->audio.flag & AUDIO_SYNC)
+    AUD_playSynchronizer();
 
-	AUD_Device_unlock(sound_device);
+  AUD_Device_unlock(sound_device);
 }
 
 void BKE_sound_stop_scene(struct Scene *scene)
 {
-	if (scene->playback_handle) {
-		AUD_Handle_pause(scene->playback_handle);
+  if (scene->playback_handle) {
+    AUD_Handle_pause(scene->playback_handle);
 
-		if (scene->audio.flag & AUDIO_SYNC)
-			AUD_stopSynchronizer();
-	}
+    if (scene->audio.flag & AUDIO_SYNC)
+      AUD_stopSynchronizer();
+  }
 }
 
 void BKE_sound_seek_scene(struct Main *bmain, struct Scene *scene)
 {
-	AUD_Status status;
-	bScreen *screen;
-	int animation_playing;
-
-	const float one_frame = (float)(1.0 / FPS);
-	const float cur_time = (float)((double)CFRA / FPS);
-
-	AUD_Device_lock(sound_device);
-
-	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_Device_unlock(sound_device);
-			return;
-		}
-
-		AUD_Handle_pause(scene->playback_handle);
-	}
-
-	animation_playing = 0;
-	for (screen = bmain->screens.first; screen; screen = screen->id.next) {
-		if (screen->animtimer) {
-			animation_playing = 1;
-			break;
-		}
-	}
-
-	if (scene->audio.flag & AUDIO_SCRUB && !animation_playing) {
-		AUD_Handle_setPosition(scene->playback_handle, cur_time);
-		if (scene->audio.flag & AUDIO_SYNC) {
-			AUD_seekSynchronizer(scene->playback_handle, cur_time);
-		}
-		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_Handle_stop(scene->sound_scrub_handle);
-			}
-			scene->sound_scrub_handle = AUD_pauseAfter(scene->playback_handle, one_frame);
-		}
-	}
-	else {
-		if (scene->audio.flag & AUDIO_SYNC) {
-			AUD_seekSynchronizer(scene->playback_handle, cur_time);
-		}
-		else {
-			if (status == AUD_STATUS_PLAYING) {
-				AUD_Handle_setPosition(scene->playback_handle, cur_time);
-			}
-		}
-	}
-
-	AUD_Device_unlock(sound_device);
+  AUD_Status status;
+  bScreen *screen;
+  int animation_playing;
+
+  const float one_frame = (float)(1.0 / FPS);
+  const float cur_time = (float)((double)CFRA / FPS);
+
+  AUD_Device_lock(sound_device);
+
+  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_Device_unlock(sound_device);
+      return;
+    }
+
+    AUD_Handle_pause(scene->playback_handle);
+  }
+
+  animation_playing = 0;
+  for (screen = bmain->screens.first; screen; screen = screen->id.next) {
+    if (screen->animtimer) {
+      animation_playing = 1;
+      break;
+    }
+  }
+
+  if (scene->audio.flag & AUDIO_SCRUB && !animation_playing) {
+    AUD_Handle_setPosition(scene->playback_handle, cur_time);
+    if (scene->audio.flag & AUDIO_SYNC) {
+      AUD_seekSynchronizer(scene->playback_handle, cur_time);
+    }
+    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_Handle_stop(scene->sound_scrub_handle);
+      }
+      scene->sound_scrub_handle = AUD_pauseAfter(scene->playback_handle, one_frame);
+    }
+  }
+  else {
+    if (scene->audio.flag & AUDIO_SYNC) {
+      AUD_seekSynchronizer(scene->playback_handle, cur_time);
+    }
+    else {
+      if (status == AUD_STATUS_PLAYING) {
+        AUD_Handle_setPosition(scene->playback_handle, cur_time);
+      }
+    }
+  }
+
+  AUD_Device_unlock(sound_device);
 }
 
 float BKE_sound_sync_scene(struct Scene *scene)
 {
-	// Ugly: Blender doesn't like it when the animation is played back during rendering
-	if (G.is_rendering)
-		return NAN_FLT;
-
-	if (scene->playback_handle) {
-		if (scene->audio.flag & AUDIO_SYNC)
-			return AUD_getSynchronizerPosition(scene->playback_handle);
-		else
-			return AUD_Handle_getPosition(scene->playback_handle);
-	}
-	return NAN_FLT;
+  // Ugly: Blender doesn't like it when the animation is played back during rendering
+  if (G.is_rendering)
+    return NAN_FLT;
+
+  if (scene->playback_handle) {
+    if (scene->audio.flag & AUDIO_SYNC)
+      return AUD_getSynchronizerPosition(scene->playback_handle);
+    else
+      return AUD_Handle_getPosition(scene->playback_handle);
+  }
+  return NAN_FLT;
 }
 
 int BKE_sound_scene_playing(struct Scene *scene)
 {
-	// Ugly: Blender doesn't like it when the animation is played back during rendering
-	if (G.is_rendering)
-		return -1;
-
-	if (scene->audio.flag & AUDIO_SYNC)
-		return AUD_isSynchronizerPlaying();
-	else
-		return -1;
+  // Ugly: Blender doesn't like it when the animation is played back during rendering
+  if (G.is_rendering)
+    return -1;
+
+  if (scene->audio.flag & AUDIO_SYNC)
+    return AUD_isSynchronizerPlaying();
+  else
+    return -1;
 }
 
 void BKE_sound_free_waveform(bSound *sound)
 {
-	if ((sound->tags & SOUND_TAGS_WAVEFORM_NO_RELOAD) == 0) {
-		SoundWaveform *waveform = sound->waveform;
-		if (waveform) {
-			if (waveform->data) {
-				MEM_freeN(waveform->data);
-			}
-			MEM_freeN(waveform);
-		}
-
-		sound->waveform = NULL;
-	}
-	/* This tag is only valid once. */
-	sound->tags &= ~SOUND_TAGS_WAVEFORM_NO_RELOAD;
+  if ((sound->tags & SOUND_TAGS_WAVEFORM_NO_RELOAD) == 0) {
+    SoundWaveform *waveform = sound->waveform;
+    if (waveform) {
+      if (waveform->data) {
+        MEM_freeN(waveform->data);
+      }
+      MEM_freeN(waveform);
+    }
+
+    sound->waveform = NULL;
+  }
+  /* This tag is only valid once. */
+  sound->tags &= ~SOUND_TAGS_WAVEFORM_NO_RELOAD;
 }
 
 void BKE_sound_read_waveform(bSound *sound, short *stop)
 {
-	AUD_SoundInfo info = AUD_getInfo(sound->playback_handle);
-	SoundWaveform *waveform = MEM_mallocN(sizeof(SoundWaveform), "SoundWaveform");
-
-	if (info.length > 0) {
-		int length = info.length * SOUND_WAVE_SAMPLES_PER_SECOND;
-
-		waveform->data = MEM_mallocN(length * sizeof(float) * 3, "SoundWaveform.samples");
-		waveform->length = AUD_readSound(sound->playback_handle, waveform->data, length, SOUND_WAVE_SAMPLES_PER_SECOND, stop);
-	}
-	else {
-		/* Create an empty waveform here if the sound couldn't be
-		 * read. This indicates that reading the waveform is "done",
-		 * whereas just setting sound->waveform to NULL causes other
-		 * code to think the waveform still needs to be created. */
-		waveform->data = NULL;
-		waveform->length = 0;
-	}
-
-	if (*stop) {
-		if (waveform->data) {
-			MEM_freeN(waveform->data);
-		}
-		MEM_freeN(waveform);
-		BLI_spin_lock(sound->spinlock);
-		sound->tags &= ~SOUND_TAGS_WAVEFORM_LOADING;
-		BLI_spin_unlock(sound->spinlock);
-		return;
-	}
-
-	BKE_sound_free_waveform(sound);
-
-	BLI_spin_lock(sound->spinlock);
-	sound->waveform = waveform;
-	sound->tags &= ~SOUND_TAGS_WAVEFORM_LOADING;
-	BLI_spin_unlock(sound->spinlock);
+  AUD_SoundInfo info = AUD_getInfo(sound->playback_handle);
+  SoundWaveform *waveform = MEM_mallocN(sizeof(SoundWaveform), "SoundWaveform");
+
+  if (info.length > 0) {
+    int length = info.length * SOUND_WAVE_SAMPLES_PER_SECOND;
+
+    waveform->data = MEM_mallocN(length * sizeof(float) * 3, "SoundWaveform.samples");
+    waveform->length = AUD_readSound(
+        sound->playback_handle, waveform->data, length, SOUND_WAVE_SAMPLES_PER_SECOND, stop);
+  }
+  else {
+    /* Create an empty waveform here if the sound couldn't be
+     * read. This indicates that reading the waveform is "done",
+     * whereas just setting sound->waveform to NULL causes other
+     * code to think the waveform still needs to be created. */
+    waveform->data = NULL;
+    waveform->length = 0;
+  }
+
+  if (*stop) {
+    if (waveform->data) {
+      MEM_freeN(waveform->data);
+    }
+    MEM_freeN(waveform);
+    BLI_spin_lock(sound->spinlock);
+    sound->tags &= ~SOUND_TAGS_WAVEFORM_LOADING;
+    BLI_spin_unlock(sound->spinlock);
+    return;
+  }
+
+  BKE_sound_free_waveform(sound);
+
+  BLI_spin_lock(sound->spinlock);
+  sound->waveform = waveform;
+  sound->tags &= ~SOUND_TAGS_WAVEFORM_LOADING;
+  BLI_spin_unlock(sound->spinlock);
 }
 
 static void sound_update_base(Scene *scene, Base *base, void *new_set)
 {
-	Object *ob = base->object;
-	NlaTrack *track;
-	NlaStrip *strip;
-	Speaker *speaker;
-	float quat[4];
-
-	if ((ob->id.tag & LIB_TAG_DOIT) == 0) {
-		return;
-	}
-
-	ob->id.tag &= ~LIB_TAG_DOIT;
-
-	if ((ob->type != OB_SPEAKER) || !ob->adt) {
-		return;
-	}
-
-	for (track = ob->adt->nla_tracks.first; track; track = track->next) {
-		for (strip = track->strips.first; strip; strip = strip->next) {
-			if (strip->type != NLASTRIP_TYPE_SOUND) {
-				continue;
-			}
-			speaker = (Speaker *)ob->data;
-
-			if (AUD_removeSet(scene->speaker_handles, strip->speaker_handle)) {
-				if (speaker->sound) {
-					AUD_SequenceEntry_move(strip->speaker_handle, (double)strip->start / FPS, FLT_MAX, 0);
-				}
-				else {
-					AUD_Sequence_remove(scene->sound_scene, strip->speaker_handle);
-					strip->speaker_handle = NULL;
-				}
-			}
-			else {
-				if (speaker->sound) {
-					strip->speaker_handle = AUD_Sequence_add(scene->sound_scene,
-					                                        speaker->sound->playback_handle,
-					                                        (double)strip->start / FPS, FLT_MAX, 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_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_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);
-			}
-		}
-	}
+  Object *ob = base->object;
+  NlaTrack *track;
+  NlaStrip *strip;
+  Speaker *speaker;
+  float quat[4];
+
+  if ((ob->id.tag & LIB_TAG_DOIT) == 0) {
+    return;
+  }
+
+  ob->id.tag &= ~LIB_TAG_DOIT;
+
+  if ((ob->type != OB_SPEAKER) || !ob->adt) {
+    return;
+  }
+
+  for (track = ob->adt->nla_tracks.first; track; track = track->next) {
+    for (strip = track->strips.first; strip; strip = strip->next) {
+      if (strip->type != NLASTRIP_TYPE_SOUND) {
+        continue;
+      }
+      speaker = (Speaker *)ob->data;
+
+      if (AUD_removeSet(scene->speaker_handles, strip->speaker_handle)) {
+        if (speaker->sound) {
+          AUD_SequenceEntry_move(strip->speaker_handle, (double)strip->start / FPS, FLT_MAX, 0);
+        }
+        else {
+          AUD_Sequence_remove(scene->sound_scene, strip->speaker_handle);
+          strip->speaker_handle = NULL;
+        }
+      }
+      else {
+        if (speaker->sound) {
+          strip->speaker_handle = AUD_Sequence_add(scene->sound_scene,
+                                                   speaker->sound->playback_handle,
+                                                   (double)strip->start / FPS,
+                                                   FLT_MAX,
+                                                   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_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_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);
+      }
+    }
+  }
 }
 
 void BKE_sound_update_scene(Main *bmain, Scene *scene)
 {
-	Base *base;
-	Scene *sce_it;
-
-	void *new_set = AUD_createSet();
-	void *handle;
-	float quat[4];
-
-	/* cheap test to skip looping over all objects (no speakers is a common case) */
-	if (!BLI_listbase_is_empty(&bmain->speakers)) {
-		BKE_main_id_tag_listbase(&bmain->objects, LIB_TAG_DOIT, true);
-
-		for (ViewLayer *view_layer = scene->view_layers.first; view_layer; view_layer = view_layer->next) {
-			for (base = view_layer->object_bases.first; base; base = base->next) {
-				sound_update_base(scene, base, new_set);
-			}
-		}
-
-		for (SETLOOPER_SET_ONLY(scene, sce_it, base)) {
-			sound_update_base(scene, base, new_set);
-		}
-
-	}
-
-	while ((handle = AUD_getSet(scene->speaker_handles))) {
-		AUD_Sequence_remove(scene->sound_scene, handle);
-	}
-
-	if (scene->camera) {
-		mat4_to_quat(quat, scene->camera->obmat);
-		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);
-	scene->speaker_handles = new_set;
+  Base *base;
+  Scene *sce_it;
+
+  void *new_set = AUD_createSet();
+  void *handle;
+  float quat[4];
+
+  /* cheap test to skip looping over all objects (no speakers is a common case) */
+  if (!BLI_listbase_is_empty(&bmain->speakers)) {
+    BKE_main_id_tag_listbase(&bmain->objects, LIB_TAG_DOIT, true);
+
+    for (ViewLayer *view_layer = scene->view_layers.first; view_layer;
+         view_layer = view_layer->next) {
+      for (base = view_layer->object_bases.first; base; base = base->next) {
+        sound_update_base(scene, base, new_set);
+      }
+    }
+
+    for (SETLOOPER_SET_ONLY(scene, sce_it, base)) {
+      sound_update_base(scene, base, new_set);
+    }
+  }
+
+  while ((handle = AUD_getSet(scene->speaker_handles))) {
+    AUD_Sequence_remove(scene->sound_scene, handle);
+  }
+
+  if (scene->camera) {
+    mat4_to_quat(quat, scene->camera->obmat);
+    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);
+  scene->speaker_handles = new_set;
 }
 
 void *BKE_sound_get_factory(void *sound)
 {
-	return ((bSound *)sound)->playback_handle;
+  return ((bSound *)sound)->playback_handle;
 }
 
 /* stupid wrapper because AUD_C-API.h includes Python.h which makesrna doesn't like */
 float BKE_sound_get_length(bSound *sound)
 {
-	AUD_SoundInfo info = AUD_getInfo(sound->playback_handle);
+  AUD_SoundInfo info = AUD_getInfo(sound->playback_handle);
 
-	return info.length;
+  return info.length;
 }
 
 char **BKE_sound_get_device_names(void)
 {
-	if (audio_device_names == NULL) {
-		audio_device_names = AUD_getDeviceNames();
-	}
+  if (audio_device_names == NULL) {
+    audio_device_names = AUD_getDeviceNames();
+  }
 
-	return audio_device_names;
+  return audio_device_names;
 }
 
-#else  /* WITH_AUDASPACE */
+#else /* WITH_AUDASPACE */
 
-#include "BLI_utildefines.h"
+#  include "BLI_utildefines.h"
 
-void BKE_sound_force_device(const char *UNUSED(device)) {}
-void BKE_sound_init_once(void) {}
-void BKE_sound_init(struct Main *UNUSED(bmain)) {}
-void BKE_sound_exit(void) {}
-void BKE_sound_exit_once(void) {}
-void BKE_sound_cache(struct bSound *UNUSED(sound)) {}
-void BKE_sound_delete_cache(struct bSound *UNUSED(sound)) {}
-void BKE_sound_load(struct Main *UNUSED(bmain), struct bSound *UNUSED(sound)) {}
-void BKE_sound_create_scene(struct Scene *UNUSED(scene)) {}
-void BKE_sound_destroy_scene(struct Scene *UNUSED(scene)) {}
-void BKE_sound_reset_scene_specs(struct Scene *UNUSED(scene)) {}
-void BKE_sound_mute_scene(struct Scene *UNUSED(scene), int UNUSED(muted)) {}
-void *BKE_sound_scene_add_scene_sound(struct Scene *UNUSED(scene), struct Sequence *UNUSED(sequence),
-                                      int UNUSED(startframe), int UNUSED(endframe), int UNUSED(frameskip)) { return NULL; }
+void BKE_sound_force_device(const char *UNUSED(device))
+{
+}
+void BKE_sound_init_once(void)
+{
+}
+void BKE_sound_init(struct Main *UNUSED(bmain))
+{
+}
+void BKE_sound_exit(void)
+{
+}
+void BKE_sound_exit_once(void)
+{
+}
+void BKE_sound_cache(struct bSound *UNUSED(sound))
+{
+}
+void BKE_sound_delete_cache(struct bSound *UNUSED(sound))
+{
+}
+void BKE_sound_load(struct Main *UNUSED(bmain), struct bSound *UNUSED(sound))
+{
+}
+void BKE_sound_create_scene(struct Scene *UNUSED(scene))
+{
+}
+void BKE_sound_destroy_scene(struct Scene *UNUSED(scene))
+{
+}
+void BKE_sound_reset_scene_specs(struct Scene *UNUSED(scene))
+{
+}
+void BKE_sound_mute_scene(struct Scene *UNUSED(scene), int UNUSED(muted))
+{
+}
+void *BKE_sound_scene_add_scene_sound(struct Scene *UNUSED(scene),
+                                      struct Sequence *UNUSED(sequence),
+                                      int UNUSED(startframe),
+                                      int UNUSED(endframe),
+                                      int UNUSED(frameskip))
+{
+  return NULL;
+}
 void *BKE_sound_scene_add_scene_sound_defaults(struct Scene *UNUSED(scene),
-                                              struct Sequence *UNUSED(sequence)) { return NULL; }
-void *BKE_sound_add_scene_sound(struct Scene *UNUSED(scene), struct Sequence *UNUSED(sequence), int UNUSED(startframe),
-                                int UNUSED(endframe), int UNUSED(frameskip)) { return NULL; }
-void *BKE_sound_add_scene_sound_defaults(struct Scene *UNUSED(scene), struct Sequence *UNUSED(sequence)) { return NULL; }
-void BKE_sound_remove_scene_sound(struct Scene *UNUSED(scene), void *UNUSED(handle)) {}
-void BKE_sound_mute_scene_sound(void *UNUSED(handle), char UNUSED(mute)) {}
-void BKE_sound_move_scene_sound(struct Scene *UNUSED(scene), void *UNUSED(handle), int UNUSED(startframe),
-                                int UNUSED(endframe), int UNUSED(frameskip)) {}
-void BKE_sound_move_scene_sound_defaults(struct Scene *UNUSED(scene), struct Sequence *UNUSED(sequence)) {}
-void BKE_sound_play_scene(struct Scene *UNUSED(scene)) {}
-void BKE_sound_stop_scene(struct Scene *UNUSED(scene)) {}
-void BKE_sound_seek_scene(struct Main *UNUSED(bmain), struct Scene *UNUSED(scene)) {}
-float BKE_sound_sync_scene(struct Scene *UNUSED(scene)) { return NAN_FLT; }
-int BKE_sound_scene_playing(struct Scene *UNUSED(scene)) { return -1; }
-void BKE_sound_read_waveform(struct bSound *sound, short *stop) { UNUSED_VARS(sound, stop); }
-void BKE_sound_init_main(struct Main *UNUSED(bmain)) {}
-void BKE_sound_set_cfra(int UNUSED(cfra)) {}
-void BKE_sound_update_sequencer(struct Main *UNUSED(main), struct bSound *UNUSED(sound)) {}
-void BKE_sound_update_scene(struct Main *UNUSED(bmain), struct Scene *UNUSED(scene)) {}
-void BKE_sound_update_scene_sound(void *UNUSED(handle), struct bSound *UNUSED(sound)) {}
-void BKE_sound_update_scene_listener(struct Scene *UNUSED(scene)) {}
-void BKE_sound_update_fps(struct Scene *UNUSED(scene)) {}
-void BKE_sound_set_scene_sound_volume(void *UNUSED(handle), float UNUSED(volume), char UNUSED(animated)) {}
-void BKE_sound_set_scene_sound_pan(void *UNUSED(handle), float UNUSED(pan), char UNUSED(animated)) {}
-void BKE_sound_set_scene_volume(struct Scene *UNUSED(scene), float UNUSED(volume)) {}
-void BKE_sound_set_scene_sound_pitch(void *UNUSED(handle), float UNUSED(pitch), char UNUSED(animated)) {}
-float BKE_sound_get_length(struct bSound *UNUSED(sound)) { return 0; }
-char **BKE_sound_get_device_names(void) { static char *names[1] = {NULL}; return names; }
-
-#endif  /* WITH_AUDASPACE */
+                                               struct Sequence *UNUSED(sequence))
+{
+  return NULL;
+}
+void *BKE_sound_add_scene_sound(struct Scene *UNUSED(scene),
+                                struct Sequence *UNUSED(sequence),
+                                int UNUSED(startframe),
+                                int UNUSED(endframe),
+                                int UNUSED(frameskip))
+{
+  return NULL;
+}
+void *BKE_sound_add_scene_sound_defaults(struct Scene *UNUSED(scene),
+                                         struct Sequence *UNUSED(sequence))
+{
+  return NULL;
+}
+void BKE_sound_remove_scene_sound(struct Scene *UNUSED(scene), void *UNUSED(handle))
+{
+}
+void BKE_sound_mute_scene_sound(void *UNUSED(handle), char UNUSED(mute))
+{
+}
+void BKE_sound_move_scene_sound(struct Scene *UNUSED(scene),
+                                void *UNUSED(handle),
+                                int UNUSED(startframe),
+                                int UNUSED(endframe),
+                                int UNUSED(frameskip))
+{
+}
+void BKE_sound_move_scene_sound_defaults(struct Scene *UNUSED(scene),
+                                         struct Sequence *UNUSED(sequence))
+{
+}
+void BKE_sound_play_scene(struct Scene *UNUSED(scene))
+{
+}
+void BKE_sound_stop_scene(struct Scene *UNUSED(scene))
+{
+}
+void BKE_sound_seek_scene(struct Main *UNUSED(bmain), struct Scene *UNUSED(scene))
+{
+}
+float BKE_sound_sync_scene(struct Scene *UNUSED(scene))
+{
+  return NAN_FLT;
+}
+int BKE_sound_scene_playing(struct Scene *UNUSED(scene))
+{
+  return -1;
+}
+void BKE_sound_read_waveform(struct bSound *sound, short *stop)
+{
+  UNUSED_VARS(sound, stop);
+}
+void BKE_sound_init_main(struct Main *UNUSED(bmain))
+{
+}
+void BKE_sound_set_cfra(int UNUSED(cfra))
+{
+}
+void BKE_sound_update_sequencer(struct Main *UNUSED(main), struct bSound *UNUSED(sound))
+{
+}
+void BKE_sound_update_scene(struct Main *UNUSED(bmain), struct Scene *UNUSED(scene))
+{
+}
+void BKE_sound_update_scene_sound(void *UNUSED(handle), struct bSound *UNUSED(sound))
+{
+}
+void BKE_sound_update_scene_listener(struct Scene *UNUSED(scene))
+{
+}
+void BKE_sound_update_fps(struct Scene *UNUSED(scene))
+{
+}
+void BKE_sound_set_scene_sound_volume(void *UNUSED(handle),
+                                      float UNUSED(volume),
+                                      char UNUSED(animated))
+{
+}
+void BKE_sound_set_scene_sound_pan(void *UNUSED(handle), float UNUSED(pan), char UNUSED(animated))
+{
+}
+void BKE_sound_set_scene_volume(struct Scene *UNUSED(scene), float UNUSED(volume))
+{
+}
+void BKE_sound_set_scene_sound_pitch(void *UNUSED(handle),
+                                     float UNUSED(pitch),
+                                     char UNUSED(animated))
+{
+}
+float BKE_sound_get_length(struct bSound *UNUSED(sound))
+{
+  return 0;
+}
+char **BKE_sound_get_device_names(void)
+{
+  static char *names[1] = {NULL};
+  return names;
+}
+
+#endif /* WITH_AUDASPACE */