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

3 files changed, 643 insertions, 600 deletions

diff --git a/source/blender/editors/sound/CMakeLists.txt b/source/blender/editors/sound/CMakeLists.txt
index 8b1caa0f306..c2a88041a85 100644
--- a/source/blender/editors/sound/CMakeLists.txt
+++ b/source/blender/editors/sound/CMakeLists.txt
@@ -16,13 +16,13 @@
 # ***** END GPL LICENSE BLOCK *****
 
 set(INC
-	../include
-	../../blenkernel
-	../../blenlib
-	../../makesdna
-	../../makesrna
-	../../windowmanager
-	../../../../intern/guardedalloc
+  ../include
+  ../../blenkernel
+  ../../blenlib
+  ../../makesdna
+  ../../makesrna
+  ../../windowmanager
+  ../../../../intern/guardedalloc
 )
 
 set(INC_SYS
@@ -30,32 +30,32 @@ set(INC_SYS
 )
 
 set(SRC
-	sound_ops.c
+  sound_ops.c
 
-	sound_intern.h
+  sound_intern.h
 )
 
 set(LIB
-	bf_blenkernel
-	bf_blenlib
+  bf_blenkernel
+  bf_blenlib
 )
 
 if(WITH_AUDASPACE)
-	list(APPEND INC_SYS
-		${AUDASPACE_C_INCLUDE_DIRS}
-	)
-	list(APPEND LIB
-		bf_intern_audaspace
-	)
-	add_definitions(-DWITH_AUDASPACE)
+  list(APPEND INC_SYS
+    ${AUDASPACE_C_INCLUDE_DIRS}
+  )
+  list(APPEND LIB
+    bf_intern_audaspace
+  )
+  add_definitions(-DWITH_AUDASPACE)
 endif()
 
 if(WITH_CODEC_FFMPEG)
-	add_definitions(-DWITH_FFMPEG)
+  add_definitions(-DWITH_FFMPEG)
 endif()
 
 if(WITH_CODEC_SNDFILE)
-	add_definitions(-DWITH_SNDFILE)
+  add_definitions(-DWITH_SNDFILE)
 endif()
 
 blender_add_lib(bf_editor_sound "${SRC}" "${INC}" "${INC_SYS}" "${LIB}")
diff --git a/source/blender/editors/sound/sound_intern.h b/source/blender/editors/sound/sound_intern.h
index f648c639eca..40cdb9ccf02 100644
--- a/source/blender/editors/sound/sound_intern.h
+++ b/source/blender/editors/sound/sound_intern.h
@@ -21,9 +21,7 @@
  * \ingroup edsnd
  */
 
-
 #ifndef __SOUND_INTERN_H__
 #define __SOUND_INTERN_H__
 
-
 #endif /* __SOUND_INTERN_H__ */
diff --git a/source/blender/editors/sound/sound_ops.c b/source/blender/editors/sound/sound_ops.c
index 2a64d87fcba..31dfe0bd30a 100644
--- a/source/blender/editors/sound/sound_ops.c
+++ b/source/blender/editors/sound/sound_ops.c
@@ -21,7 +21,6 @@
  * \ingroup edsnd
  */
 
-
 #include <string.h>
 #include <stdlib.h>
 #include <stdio.h>
@@ -66,146 +65,155 @@
 #include "ED_sound.h"
 #include "ED_util.h"
 
-
 /******************** open sound operator ********************/
 
 static void sound_open_cancel(bContext *UNUSED(C), wmOperator *op)
 {
-	MEM_freeN(op->customdata);
-	op->customdata = NULL;
+  MEM_freeN(op->customdata);
+  op->customdata = NULL;
 }
 
 static void sound_open_init(bContext *C, wmOperator *op)
 {
-	PropertyPointerRNA *pprop;
+  PropertyPointerRNA *pprop;
 
-	op->customdata = pprop = MEM_callocN(sizeof(PropertyPointerRNA), "OpenPropertyPointerRNA");
-	UI_context_active_but_prop_get_templateID(C, &pprop->ptr, &pprop->prop);
+  op->customdata = pprop = MEM_callocN(sizeof(PropertyPointerRNA), "OpenPropertyPointerRNA");
+  UI_context_active_but_prop_get_templateID(C, &pprop->ptr, &pprop->prop);
 }
 
 #ifdef WITH_AUDASPACE
 static int sound_open_exec(bContext *C, wmOperator *op)
 {
-	char path[FILE_MAX];
-	bSound *sound;
-	PropertyPointerRNA *pprop;
-	PointerRNA idptr;
-	AUD_SoundInfo info;
-	Main *bmain = CTX_data_main(C);
-
-	RNA_string_get(op->ptr, "filepath", path);
-	sound = BKE_sound_new_file(bmain, path);
-
-	if (!op->customdata)
-		sound_open_init(C, op);
-
-	if (sound->playback_handle == NULL) {
-		if (op->customdata) MEM_freeN(op->customdata);
-		BKE_id_free(bmain, sound);
-		BKE_report(op->reports, RPT_ERROR, "Unsupported audio format");
-		return OPERATOR_CANCELLED;
-	}
-
-	info = AUD_getInfo(sound->playback_handle);
-
-	if (info.specs.channels == AUD_CHANNELS_INVALID) {
-		BKE_id_free(bmain, sound);
-		if (op->customdata) MEM_freeN(op->customdata);
-		BKE_report(op->reports, RPT_ERROR, "Unsupported audio format");
-		return OPERATOR_CANCELLED;
-	}
-
-	if (RNA_boolean_get(op->ptr, "mono")) {
-		sound->flags |= SOUND_FLAGS_MONO;
-		BKE_sound_load(bmain, sound);
-	}
-
-	if (RNA_boolean_get(op->ptr, "cache")) {
-		BKE_sound_cache(sound);
-	}
-
-	/* hook into UI */
-	pprop = op->customdata;
-
-	if (pprop->prop) {
-		/* when creating new ID blocks, use is already 1, but RNA
-		 * pointer use also increases user, so this compensates it */
-		id_us_min(&sound->id);
-
-		RNA_id_pointer_create(&sound->id, &idptr);
-		RNA_property_pointer_set(&pprop->ptr, pprop->prop, idptr);
-		RNA_property_update(C, &pprop->ptr, pprop->prop);
-	}
-
-	MEM_freeN(op->customdata);
-	return OPERATOR_FINISHED;
+  char path[FILE_MAX];
+  bSound *sound;
+  PropertyPointerRNA *pprop;
+  PointerRNA idptr;
+  AUD_SoundInfo info;
+  Main *bmain = CTX_data_main(C);
+
+  RNA_string_get(op->ptr, "filepath", path);
+  sound = BKE_sound_new_file(bmain, path);
+
+  if (!op->customdata)
+    sound_open_init(C, op);
+
+  if (sound->playback_handle == NULL) {
+    if (op->customdata)
+      MEM_freeN(op->customdata);
+    BKE_id_free(bmain, sound);
+    BKE_report(op->reports, RPT_ERROR, "Unsupported audio format");
+    return OPERATOR_CANCELLED;
+  }
+
+  info = AUD_getInfo(sound->playback_handle);
+
+  if (info.specs.channels == AUD_CHANNELS_INVALID) {
+    BKE_id_free(bmain, sound);
+    if (op->customdata)
+      MEM_freeN(op->customdata);
+    BKE_report(op->reports, RPT_ERROR, "Unsupported audio format");
+    return OPERATOR_CANCELLED;
+  }
+
+  if (RNA_boolean_get(op->ptr, "mono")) {
+    sound->flags |= SOUND_FLAGS_MONO;
+    BKE_sound_load(bmain, sound);
+  }
+
+  if (RNA_boolean_get(op->ptr, "cache")) {
+    BKE_sound_cache(sound);
+  }
+
+  /* hook into UI */
+  pprop = op->customdata;
+
+  if (pprop->prop) {
+    /* when creating new ID blocks, use is already 1, but RNA
+     * pointer use also increases user, so this compensates it */
+    id_us_min(&sound->id);
+
+    RNA_id_pointer_create(&sound->id, &idptr);
+    RNA_property_pointer_set(&pprop->ptr, pprop->prop, idptr);
+    RNA_property_update(C, &pprop->ptr, pprop->prop);
+  }
+
+  MEM_freeN(op->customdata);
+  return OPERATOR_FINISHED;
 }
 
-#else //WITH_AUDASPACE
+#else  //WITH_AUDASPACE
 
 static int sound_open_exec(bContext *UNUSED(C), wmOperator *op)
 {
-	BKE_report(op->reports, RPT_ERROR, "Compiled without sound support");
+  BKE_report(op->reports, RPT_ERROR, "Compiled without sound support");
 
-	return OPERATOR_CANCELLED;
+  return OPERATOR_CANCELLED;
 }
 
 #endif
 
 static int sound_open_invoke(bContext *C, wmOperator *op, const wmEvent *event)
 {
-	if (RNA_struct_property_is_set(op->ptr, "filepath"))
-		return sound_open_exec(C, op);
+  if (RNA_struct_property_is_set(op->ptr, "filepath"))
+    return sound_open_exec(C, op);
 
-	sound_open_init(C, op);
+  sound_open_init(C, op);
 
-	return WM_operator_filesel(C, op, event);
+  return WM_operator_filesel(C, op, event);
 }
 
 static void SOUND_OT_open(wmOperatorType *ot)
 {
-	/* identifiers */
-	ot->name = "Open Sound";
-	ot->description = "Load a sound file";
-	ot->idname = "SOUND_OT_open";
-
-	/* api callbacks */
-	ot->exec = sound_open_exec;
-	ot->invoke = sound_open_invoke;
-	ot->cancel = sound_open_cancel;
-
-	/* flags */
-	ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
-
-	/* properties */
-	WM_operator_properties_filesel(
-	        ot, FILE_TYPE_FOLDER | FILE_TYPE_SOUND | FILE_TYPE_MOVIE, FILE_SPECIAL, FILE_OPENFILE,
-	        WM_FILESEL_FILEPATH | WM_FILESEL_RELPATH, FILE_DEFAULTDISPLAY, FILE_SORT_ALPHA);
-	RNA_def_boolean(ot->srna, "cache", false, "Cache", "Cache the sound in memory");
-	RNA_def_boolean(ot->srna, "mono", false, "Mono", "Merge all the sound's channels into one");
+  /* identifiers */
+  ot->name = "Open Sound";
+  ot->description = "Load a sound file";
+  ot->idname = "SOUND_OT_open";
+
+  /* api callbacks */
+  ot->exec = sound_open_exec;
+  ot->invoke = sound_open_invoke;
+  ot->cancel = sound_open_cancel;
+
+  /* flags */
+  ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+
+  /* properties */
+  WM_operator_properties_filesel(ot,
+                                 FILE_TYPE_FOLDER | FILE_TYPE_SOUND | FILE_TYPE_MOVIE,
+                                 FILE_SPECIAL,
+                                 FILE_OPENFILE,
+                                 WM_FILESEL_FILEPATH | WM_FILESEL_RELPATH,
+                                 FILE_DEFAULTDISPLAY,
+                                 FILE_SORT_ALPHA);
+  RNA_def_boolean(ot->srna, "cache", false, "Cache", "Cache the sound in memory");
+  RNA_def_boolean(ot->srna, "mono", false, "Mono", "Merge all the sound's channels into one");
 }
 
 static void SOUND_OT_open_mono(wmOperatorType *ot)
 {
-	/* identifiers */
-	ot->name = "Open Sound Mono";
-	ot->description = "Load a sound file as mono";
-	ot->idname = "SOUND_OT_open_mono";
-
-	/* api callbacks */
-	ot->exec = sound_open_exec;
-	ot->invoke = sound_open_invoke;
-	ot->cancel = sound_open_cancel;
-
-	/* flags */
-	ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
-
-	/* properties */
-	WM_operator_properties_filesel(
-	        ot, FILE_TYPE_FOLDER | FILE_TYPE_SOUND | FILE_TYPE_MOVIE, FILE_SPECIAL, FILE_OPENFILE,
-	        WM_FILESEL_FILEPATH | WM_FILESEL_RELPATH, FILE_DEFAULTDISPLAY, FILE_SORT_ALPHA);
-	RNA_def_boolean(ot->srna, "cache", false, "Cache", "Cache the sound in memory");
-	RNA_def_boolean(ot->srna, "mono", true, "Mono", "Mixdown the sound to mono");
+  /* identifiers */
+  ot->name = "Open Sound Mono";
+  ot->description = "Load a sound file as mono";
+  ot->idname = "SOUND_OT_open_mono";
+
+  /* api callbacks */
+  ot->exec = sound_open_exec;
+  ot->invoke = sound_open_invoke;
+  ot->cancel = sound_open_cancel;
+
+  /* flags */
+  ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+
+  /* properties */
+  WM_operator_properties_filesel(ot,
+                                 FILE_TYPE_FOLDER | FILE_TYPE_SOUND | FILE_TYPE_MOVIE,
+                                 FILE_SPECIAL,
+                                 FILE_OPENFILE,
+                                 WM_FILESEL_FILEPATH | WM_FILESEL_RELPATH,
+                                 FILE_DEFAULTDISPLAY,
+                                 FILE_SORT_ALPHA);
+  RNA_def_boolean(ot->srna, "cache", false, "Cache", "Cache the sound in memory");
+  RNA_def_boolean(ot->srna, "mono", true, "Mono", "Mixdown the sound to mono");
 }
 
 /* ******************************************************* */
@@ -214,613 +222,650 @@ static void sound_update_animation_flags(Scene *scene);
 
 static int sound_update_animation_flags_cb(Sequence *seq, void *user_data)
 {
-	struct FCurve *fcu;
-	Scene *scene = (Scene *)user_data;
-	bool driven;
-
-	fcu = id_data_find_fcurve(&scene->id, seq, &RNA_Sequence, "volume", 0, &driven);
-	if (fcu || driven)
-		seq->flag |= SEQ_AUDIO_VOLUME_ANIMATED;
-	else
-		seq->flag &= ~SEQ_AUDIO_VOLUME_ANIMATED;
-
-	fcu = id_data_find_fcurve(&scene->id, seq, &RNA_Sequence, "pitch", 0, &driven);
-	if (fcu || driven)
-		seq->flag |= SEQ_AUDIO_PITCH_ANIMATED;
-	else
-		seq->flag &= ~SEQ_AUDIO_PITCH_ANIMATED;
-
-	fcu = id_data_find_fcurve(&scene->id, seq, &RNA_Sequence, "pan", 0, &driven);
-	if (fcu || driven)
-		seq->flag |= SEQ_AUDIO_PAN_ANIMATED;
-	else
-		seq->flag &= ~SEQ_AUDIO_PAN_ANIMATED;
-
-	if (seq->type == SEQ_TYPE_SCENE) {
-		/* TODO(sergey): For now we do manual recursion into the scene strips,
-		 * but perhaps it should be covered by recursive_apply?
-		 */
-		sound_update_animation_flags(seq->scene);
-	}
-
-	return 0;
+  struct FCurve *fcu;
+  Scene *scene = (Scene *)user_data;
+  bool driven;
+
+  fcu = id_data_find_fcurve(&scene->id, seq, &RNA_Sequence, "volume", 0, &driven);
+  if (fcu || driven)
+    seq->flag |= SEQ_AUDIO_VOLUME_ANIMATED;
+  else
+    seq->flag &= ~SEQ_AUDIO_VOLUME_ANIMATED;
+
+  fcu = id_data_find_fcurve(&scene->id, seq, &RNA_Sequence, "pitch", 0, &driven);
+  if (fcu || driven)
+    seq->flag |= SEQ_AUDIO_PITCH_ANIMATED;
+  else
+    seq->flag &= ~SEQ_AUDIO_PITCH_ANIMATED;
+
+  fcu = id_data_find_fcurve(&scene->id, seq, &RNA_Sequence, "pan", 0, &driven);
+  if (fcu || driven)
+    seq->flag |= SEQ_AUDIO_PAN_ANIMATED;
+  else
+    seq->flag &= ~SEQ_AUDIO_PAN_ANIMATED;
+
+  if (seq->type == SEQ_TYPE_SCENE) {
+    /* TODO(sergey): For now we do manual recursion into the scene strips,
+     * but perhaps it should be covered by recursive_apply?
+     */
+    sound_update_animation_flags(seq->scene);
+  }
+
+  return 0;
 }
 
 static void sound_update_animation_flags(Scene *scene)
 {
-	struct FCurve *fcu;
-	bool driven;
-	Sequence *seq;
-
-	if (scene->id.tag & LIB_TAG_DOIT) {
-		return;
-	}
-	scene->id.tag |= LIB_TAG_DOIT;
-
-	SEQ_BEGIN(scene->ed, seq)
-	{
-		BKE_sequencer_recursive_apply(seq, sound_update_animation_flags_cb, scene);
-	} SEQ_END;
-
-	fcu = id_data_find_fcurve(&scene->id, scene, &RNA_Scene, "audio_volume", 0, &driven);
-	if (fcu || driven)
-		scene->audio.flag |= AUDIO_VOLUME_ANIMATED;
-	else
-		scene->audio.flag &= ~AUDIO_VOLUME_ANIMATED;
+  struct FCurve *fcu;
+  bool driven;
+  Sequence *seq;
+
+  if (scene->id.tag & LIB_TAG_DOIT) {
+    return;
+  }
+  scene->id.tag |= LIB_TAG_DOIT;
+
+  SEQ_BEGIN (scene->ed, seq) {
+    BKE_sequencer_recursive_apply(seq, sound_update_animation_flags_cb, scene);
+  }
+  SEQ_END;
+
+  fcu = id_data_find_fcurve(&scene->id, scene, &RNA_Scene, "audio_volume", 0, &driven);
+  if (fcu || driven)
+    scene->audio.flag |= AUDIO_VOLUME_ANIMATED;
+  else
+    scene->audio.flag &= ~AUDIO_VOLUME_ANIMATED;
 }
 
 static int sound_update_animation_flags_exec(bContext *C, wmOperator *UNUSED(op))
 {
-	BKE_main_id_tag_idcode(CTX_data_main(C), ID_SCE, LIB_TAG_DOIT, false);
-	sound_update_animation_flags(CTX_data_scene(C));
-	return OPERATOR_FINISHED;
+  BKE_main_id_tag_idcode(CTX_data_main(C), ID_SCE, LIB_TAG_DOIT, false);
+  sound_update_animation_flags(CTX_data_scene(C));
+  return OPERATOR_FINISHED;
 }
 
 static void SOUND_OT_update_animation_flags(wmOperatorType *ot)
 {
-	/*
-	 * This operator is needed to set a correct state of the sound animation
-	 * System. Unfortunately there's no really correct place to call the exec
-	 * function, that's why I made it an operator that's only visible in the
-	 * search menu. Apart from that the bake animation operator calls it too.
-	 */
-
-	/* identifiers */
-	ot->name = "Update Animation";
-	ot->description = "Update animation flags";
-	ot->idname = "SOUND_OT_update_animation_flags";
-
-	/* api callbacks */
-	ot->exec = sound_update_animation_flags_exec;
-
-	/* flags */
-	ot->flag = OPTYPE_REGISTER;
+  /*
+   * This operator is needed to set a correct state of the sound animation
+   * System. Unfortunately there's no really correct place to call the exec
+   * function, that's why I made it an operator that's only visible in the
+   * search menu. Apart from that the bake animation operator calls it too.
+   */
+
+  /* identifiers */
+  ot->name = "Update Animation";
+  ot->description = "Update animation flags";
+  ot->idname = "SOUND_OT_update_animation_flags";
+
+  /* api callbacks */
+  ot->exec = sound_update_animation_flags_exec;
+
+  /* flags */
+  ot->flag = OPTYPE_REGISTER;
 }
 
 /* ******************************************************* */
 
 static int sound_bake_animation_exec(bContext *C, wmOperator *UNUSED(op))
 {
-	Main *bmain = CTX_data_main(C);
-	Scene *scene = CTX_data_scene(C);
-	struct Depsgraph *depsgraph = CTX_data_depsgraph(C);
-	int oldfra = scene->r.cfra;
-	int cfra;
+  Main *bmain = CTX_data_main(C);
+  Scene *scene = CTX_data_scene(C);
+  struct Depsgraph *depsgraph = CTX_data_depsgraph(C);
+  int oldfra = scene->r.cfra;
+  int cfra;
 
-	sound_update_animation_flags_exec(C, NULL);
+  sound_update_animation_flags_exec(C, NULL);
 
-	for (cfra = (scene->r.sfra > 0) ? (scene->r.sfra - 1) : 0; cfra <= scene->r.efra + 1; cfra++) {
-		scene->r.cfra = cfra;
-		BKE_scene_graph_update_for_newframe(depsgraph, bmain);
-	}
+  for (cfra = (scene->r.sfra > 0) ? (scene->r.sfra - 1) : 0; cfra <= scene->r.efra + 1; cfra++) {
+    scene->r.cfra = cfra;
+    BKE_scene_graph_update_for_newframe(depsgraph, bmain);
+  }
 
-	scene->r.cfra = oldfra;
-	BKE_scene_graph_update_for_newframe(depsgraph, bmain);
+  scene->r.cfra = oldfra;
+  BKE_scene_graph_update_for_newframe(depsgraph, bmain);
 
-	return OPERATOR_FINISHED;
+  return OPERATOR_FINISHED;
 }
 
 static void SOUND_OT_bake_animation(wmOperatorType *ot)
 {
-	/* identifiers */
-	ot->name = "Update Animation Cache";
-	ot->description = "Update the audio animation cache";
-	ot->idname = "SOUND_OT_bake_animation";
+  /* identifiers */
+  ot->name = "Update Animation Cache";
+  ot->description = "Update the audio animation cache";
+  ot->idname = "SOUND_OT_bake_animation";
 
-	/* api callbacks */
-	ot->exec = sound_bake_animation_exec;
+  /* api callbacks */
+  ot->exec = sound_bake_animation_exec;
 
-	/* flags */
-	ot->flag = OPTYPE_REGISTER;
+  /* flags */
+  ot->flag = OPTYPE_REGISTER;
 }
 
-
 /******************** mixdown operator ********************/
 
 static int sound_mixdown_exec(bContext *C, wmOperator *op)
 {
 #ifdef WITH_AUDASPACE
-	char path[FILE_MAX];
-	char filename[FILE_MAX];
-	Scene *scene;
-	Main *bmain;
-	int split;
-
-	int bitrate, accuracy;
-	AUD_DeviceSpecs specs;
-	AUD_Container container;
-	AUD_Codec codec;
-	const char *result;
-
-	sound_bake_animation_exec(C, op);
-
-	RNA_string_get(op->ptr, "filepath", path);
-	bitrate = RNA_int_get(op->ptr, "bitrate") * 1000;
-	accuracy = RNA_int_get(op->ptr, "accuracy");
-	specs.format = RNA_enum_get(op->ptr, "format");
-	container = RNA_enum_get(op->ptr, "container");
-	codec = RNA_enum_get(op->ptr, "codec");
-	split = RNA_boolean_get(op->ptr, "split_channels");
-	scene = CTX_data_scene(C);
-	bmain = CTX_data_main(C);
-	specs.channels = scene->r.ffcodecdata.audio_channels;
-	specs.rate = scene->r.ffcodecdata.audio_mixrate;
-
-	BLI_strncpy(filename, path, sizeof(filename));
-	BLI_path_abs(filename, BKE_main_blendfile_path(bmain));
-
-	if (split)
-		result = AUD_mixdown_per_channel(scene->sound_scene, SFRA * specs.rate / FPS, (EFRA - SFRA + 1) * specs.rate / FPS,
-		                                 accuracy, filename, specs, container, codec, bitrate);
-	else
-		result = AUD_mixdown(scene->sound_scene, SFRA * specs.rate / FPS, (EFRA - SFRA + 1) * specs.rate / FPS,
-		                     accuracy, filename, specs, container, codec, bitrate);
-
-	BKE_sound_reset_scene_specs(scene);
-
-	if (result) {
-		BKE_report(op->reports, RPT_ERROR, result);
-		return OPERATOR_CANCELLED;
-	}
-#else // WITH_AUDASPACE
-	(void)C;
-	(void)op;
-#endif // WITH_AUDASPACE
-	return OPERATOR_FINISHED;
+  char path[FILE_MAX];
+  char filename[FILE_MAX];
+  Scene *scene;
+  Main *bmain;
+  int split;
+
+  int bitrate, accuracy;
+  AUD_DeviceSpecs specs;
+  AUD_Container container;
+  AUD_Codec codec;
+  const char *result;
+
+  sound_bake_animation_exec(C, op);
+
+  RNA_string_get(op->ptr, "filepath", path);
+  bitrate = RNA_int_get(op->ptr, "bitrate") * 1000;
+  accuracy = RNA_int_get(op->ptr, "accuracy");
+  specs.format = RNA_enum_get(op->ptr, "format");
+  container = RNA_enum_get(op->ptr, "container");
+  codec = RNA_enum_get(op->ptr, "codec");
+  split = RNA_boolean_get(op->ptr, "split_channels");
+  scene = CTX_data_scene(C);
+  bmain = CTX_data_main(C);
+  specs.channels = scene->r.ffcodecdata.audio_channels;
+  specs.rate = scene->r.ffcodecdata.audio_mixrate;
+
+  BLI_strncpy(filename, path, sizeof(filename));
+  BLI_path_abs(filename, BKE_main_blendfile_path(bmain));
+
+  if (split)
+    result = AUD_mixdown_per_channel(scene->sound_scene,
+                                     SFRA * specs.rate / FPS,
+                                     (EFRA - SFRA + 1) * specs.rate / FPS,
+                                     accuracy,
+                                     filename,
+                                     specs,
+                                     container,
+                                     codec,
+                                     bitrate);
+  else
+    result = AUD_mixdown(scene->sound_scene,
+                         SFRA * specs.rate / FPS,
+                         (EFRA - SFRA + 1) * specs.rate / FPS,
+                         accuracy,
+                         filename,
+                         specs,
+                         container,
+                         codec,
+                         bitrate);
+
+  BKE_sound_reset_scene_specs(scene);
+
+  if (result) {
+    BKE_report(op->reports, RPT_ERROR, result);
+    return OPERATOR_CANCELLED;
+  }
+#else   // WITH_AUDASPACE
+  (void)C;
+  (void)op;
+#endif  // WITH_AUDASPACE
+  return OPERATOR_FINISHED;
 }
 
 #ifdef WITH_AUDASPACE
 static const EnumPropertyItem container_items[] = {
-#ifdef WITH_FFMPEG
-	{AUD_CONTAINER_AC3, "AC3", 0, "ac3", "Dolby Digital ATRAC 3"},
-#endif
-	{AUD_CONTAINER_FLAC, "FLAC", 0, "flac", "Free Lossless Audio Codec"},
-#ifdef WITH_FFMPEG
-	{AUD_CONTAINER_MATROSKA, "MATROSKA", 0, "mkv", "Matroska"},
-	{AUD_CONTAINER_MP2, "MP2", 0, "mp2", "MPEG-1 Audio Layer II"},
-	{AUD_CONTAINER_MP3, "MP3", 0, "mp3", "MPEG-2 Audio Layer III"},
-#endif
-	{AUD_CONTAINER_OGG, "OGG", 0, "ogg", "Xiph.Org Ogg Container"},
-	{AUD_CONTAINER_WAV, "WAV", 0, "wav", "Waveform Audio File Format"},
-	{0, NULL, 0, NULL, NULL},
+#  ifdef WITH_FFMPEG
+    {AUD_CONTAINER_AC3, "AC3", 0, "ac3", "Dolby Digital ATRAC 3"},
+#  endif
+    {AUD_CONTAINER_FLAC, "FLAC", 0, "flac", "Free Lossless Audio Codec"},
+#  ifdef WITH_FFMPEG
+    {AUD_CONTAINER_MATROSKA, "MATROSKA", 0, "mkv", "Matroska"},
+    {AUD_CONTAINER_MP2, "MP2", 0, "mp2", "MPEG-1 Audio Layer II"},
+    {AUD_CONTAINER_MP3, "MP3", 0, "mp3", "MPEG-2 Audio Layer III"},
+#  endif
+    {AUD_CONTAINER_OGG, "OGG", 0, "ogg", "Xiph.Org Ogg Container"},
+    {AUD_CONTAINER_WAV, "WAV", 0, "wav", "Waveform Audio File Format"},
+    {0, NULL, 0, NULL, NULL},
 };
 
 static const char *snd_ext_sound[] = {
-	".ac3",
-	".flac",
-	".mkv",
-	".mp2",
-	".mp3",
-	".ogg",
-	".wav",
-	NULL,
+    ".ac3",
+    ".flac",
+    ".mkv",
+    ".mp2",
+    ".mp3",
+    ".ogg",
+    ".wav",
+    NULL,
 };
 
 static bool sound_mixdown_check(bContext *UNUSED(C), wmOperator *op)
 {
-	AUD_Container container = RNA_enum_get(op->ptr, "container");
+  AUD_Container container = RNA_enum_get(op->ptr, "container");
 
-	const char *extension = NULL;
+  const char *extension = NULL;
 
-	const EnumPropertyItem *item = container_items;
-	while (item->identifier != NULL) {
-		if (item->value == container) {
-			const char **ext = snd_ext_sound;
-			while (*ext != NULL) {
-				if (STREQ(*ext + 1, item->name)) {
-					extension = *ext;
-					break;
-				}
+  const EnumPropertyItem *item = container_items;
+  while (item->identifier != NULL) {
+    if (item->value == container) {
+      const char **ext = snd_ext_sound;
+      while (*ext != NULL) {
+        if (STREQ(*ext + 1, item->name)) {
+          extension = *ext;
+          break;
+        }
 
-				ext++;
-			}
-		}
-		item++;
-	}
+        ext++;
+      }
+    }
+    item++;
+  }
 
-	if (extension) {
-		PropertyRNA *prop;
-		char filepath[FILE_MAX];
+  if (extension) {
+    PropertyRNA *prop;
+    char filepath[FILE_MAX];
 
-		int check;
+    int check;
 
-		prop = RNA_struct_find_property(op->ptr, "filepath");
-		RNA_property_string_get(op->ptr, prop, filepath);
+    prop = RNA_struct_find_property(op->ptr, "filepath");
+    RNA_property_string_get(op->ptr, prop, filepath);
 
-		if (BLI_path_extension_check_array(filepath, snd_ext_sound))
-			check = BLI_path_extension_replace(filepath, FILE_MAX, extension);
-		else
-			check = BLI_path_extension_ensure(filepath, FILE_MAX, extension);
+    if (BLI_path_extension_check_array(filepath, snd_ext_sound))
+      check = BLI_path_extension_replace(filepath, FILE_MAX, extension);
+    else
+      check = BLI_path_extension_ensure(filepath, FILE_MAX, extension);
 
-		if (!check)
-			return check;
+    if (!check)
+      return check;
 
-		RNA_property_string_set(op->ptr, prop, filepath);
-		return true;
-	}
+    RNA_property_string_set(op->ptr, prop, filepath);
+    return true;
+  }
 
-	return false;
+  return false;
 }
 
-#endif // WITH_AUDASPACE
+#endif  // WITH_AUDASPACE
 
 static int sound_mixdown_invoke(bContext *C, wmOperator *op, const wmEvent *event)
 {
-	if (RNA_struct_property_is_set(op->ptr, "filepath"))
-		return sound_mixdown_exec(C, op);
+  if (RNA_struct_property_is_set(op->ptr, "filepath"))
+    return sound_mixdown_exec(C, op);
 
-	return WM_operator_filesel(C, op, event);
+  return WM_operator_filesel(C, op, event);
 }
 
 #ifdef WITH_AUDASPACE
 
-static bool sound_mixdown_draw_check_prop(PointerRNA *UNUSED(ptr), PropertyRNA *prop, void *UNUSED(user_data))
+static bool sound_mixdown_draw_check_prop(PointerRNA *UNUSED(ptr),
+                                          PropertyRNA *prop,
+                                          void *UNUSED(user_data))
 {
-	const char *prop_id = RNA_property_identifier(prop);
-	return !(STREQ(prop_id, "filepath") ||
-	         STREQ(prop_id, "directory") ||
-	         STREQ(prop_id, "filename"));
+  const char *prop_id = RNA_property_identifier(prop);
+  return !(STREQ(prop_id, "filepath") || STREQ(prop_id, "directory") ||
+           STREQ(prop_id, "filename"));
 }
 
 static void sound_mixdown_draw(bContext *C, wmOperator *op)
 {
-	static const EnumPropertyItem pcm_format_items[] = {
-		{AUD_FORMAT_U8, "U8", 0, "U8", "8 bit unsigned"},
-		{AUD_FORMAT_S16, "S16", 0, "S16", "16 bit signed"},
-#ifdef WITH_SNDFILE
-		{AUD_FORMAT_S24, "S24", 0, "S24", "24 bit signed"},
-#endif
-		{AUD_FORMAT_S32, "S32", 0, "S32", "32 bit signed"},
-		{AUD_FORMAT_FLOAT32, "F32", 0, "F32", "32 bit floating point"},
-		{AUD_FORMAT_FLOAT64, "F64", 0, "F64", "64 bit floating point"},
-		{0, NULL, 0, NULL, NULL},
-	};
-
-	static const EnumPropertyItem mp3_format_items[] = {
-		{AUD_FORMAT_S16, "S16", 0, "S16", "16 bit signed"},
-		{AUD_FORMAT_S32, "S32", 0, "S32", "32 bit signed"},
-		{0, NULL, 0, NULL, NULL},
-	};
-
-#ifdef WITH_SNDFILE
-	static const EnumPropertyItem flac_format_items[] = {
-		{AUD_FORMAT_S16, "S16", 0, "S16", "16 bit signed"},
-		{AUD_FORMAT_S24, "S24", 0, "S24", "24 bit signed"},
-		{0, NULL, 0, NULL, NULL},
-	};
-#endif
-
-	static const EnumPropertyItem all_codec_items[] = {
-		{AUD_CODEC_AAC, "AAC", 0, "AAC", "Advanced Audio Coding"},
-		{AUD_CODEC_AC3, "AC3", 0, "AC3", "Dolby Digital ATRAC 3"},
-		{AUD_CODEC_FLAC, "FLAC", 0, "FLAC", "Free Lossless Audio Codec"},
-		{AUD_CODEC_MP2, "MP2", 0, "MP2", "MPEG-1 Audio Layer II"},
-		{AUD_CODEC_MP3, "MP3", 0, "MP3", "MPEG-2 Audio Layer III"},
-		{AUD_CODEC_PCM, "PCM", 0, "PCM", "Pulse Code Modulation (RAW)"},
-		{AUD_CODEC_VORBIS, "VORBIS", 0, "Vorbis", "Xiph.Org Vorbis Codec"},
-		{0, NULL, 0, NULL, NULL},
-	};
-
-	static const EnumPropertyItem ogg_codec_items[] = {
-		{AUD_CODEC_FLAC, "FLAC", 0, "FLAC", "Free Lossless Audio Codec"},
-		{AUD_CODEC_VORBIS, "VORBIS", 0, "Vorbis", "Xiph.Org Vorbis Codec"},
-		{0, NULL, 0, NULL, NULL},
-	};
-
-	uiLayout *layout = op->layout;
-	wmWindowManager *wm = CTX_wm_manager(C);
-	PointerRNA ptr;
-	PropertyRNA *prop_format;
-	PropertyRNA *prop_codec;
-	PropertyRNA *prop_bitrate;
-
-	AUD_Container container = RNA_enum_get(op->ptr, "container");
-	AUD_Codec codec = RNA_enum_get(op->ptr, "codec");
-
-	prop_format = RNA_struct_find_property(op->ptr, "format");
-	prop_codec = RNA_struct_find_property(op->ptr, "codec");
-	prop_bitrate = RNA_struct_find_property(op->ptr, "bitrate");
-
-	RNA_def_property_clear_flag(prop_bitrate, PROP_HIDDEN);
-	RNA_def_property_flag(prop_codec, PROP_HIDDEN);
-	RNA_def_property_flag(prop_format, PROP_HIDDEN);
-
-	switch (container) {
-		case AUD_CONTAINER_AC3:
-			RNA_def_property_enum_items(prop_codec, all_codec_items);
-			RNA_enum_set(op->ptr, "codec", AUD_CODEC_AC3);
-			RNA_enum_set(op->ptr, "format", AUD_FORMAT_FLOAT32);
-			break;
-		case AUD_CONTAINER_FLAC:
-			RNA_def_property_flag(prop_bitrate, PROP_HIDDEN);
-			RNA_def_property_enum_items(prop_codec, all_codec_items);
-			RNA_enum_set(op->ptr, "codec", AUD_CODEC_FLAC);
-#ifdef WITH_SNDFILE
-			RNA_def_property_clear_flag(prop_format, PROP_HIDDEN);
-			RNA_def_property_enum_items(prop_format, flac_format_items);
-#else
-			RNA_enum_set(op->ptr, "format", AUD_FORMAT_S16);
-#endif
-			break;
-		case AUD_CONTAINER_MATROSKA:
-			RNA_def_property_clear_flag(prop_codec, PROP_HIDDEN);
-			RNA_def_property_enum_items(prop_codec, all_codec_items);
-
-			switch (codec) {
-				case AUD_CODEC_AAC:
-					RNA_enum_set(op->ptr, "format", AUD_FORMAT_S16);
-					break;
-				case AUD_CODEC_AC3:
-					RNA_enum_set(op->ptr, "format", AUD_FORMAT_FLOAT32);
-					break;
-				case AUD_CODEC_FLAC:
-					RNA_def_property_flag(prop_bitrate, PROP_HIDDEN);
-					RNA_enum_set(op->ptr, "format", AUD_FORMAT_S16);
-					break;
-				case AUD_CODEC_MP2:
-					RNA_enum_set(op->ptr, "format", AUD_FORMAT_S16);
-					break;
-				case AUD_CODEC_MP3:
-					RNA_def_property_enum_items(prop_format, mp3_format_items);
-					RNA_def_property_clear_flag(prop_format, PROP_HIDDEN);
-					break;
-				case AUD_CODEC_PCM:
-					RNA_def_property_flag(prop_bitrate, PROP_HIDDEN);
-					RNA_def_property_enum_items(prop_format, pcm_format_items);
-					RNA_def_property_clear_flag(prop_format, PROP_HIDDEN);
-					break;
-				case AUD_CODEC_VORBIS:
-					RNA_enum_set(op->ptr, "format", AUD_FORMAT_S16);
-					break;
-				default:
-					break;
-			}
-
-			break;
-		case AUD_CONTAINER_MP2:
-			RNA_enum_set(op->ptr, "format", AUD_FORMAT_S16);
-			RNA_enum_set(op->ptr, "codec", AUD_CODEC_MP2);
-			RNA_def_property_enum_items(prop_codec, all_codec_items);
-			break;
-		case AUD_CONTAINER_MP3:
-			RNA_def_property_clear_flag(prop_format, PROP_HIDDEN);
-			RNA_def_property_enum_items(prop_format, mp3_format_items);
-			RNA_def_property_enum_items(prop_codec, all_codec_items);
-			RNA_enum_set(op->ptr, "codec", AUD_CODEC_MP3);
-			break;
-		case AUD_CONTAINER_OGG:
-			RNA_def_property_clear_flag(prop_codec, PROP_HIDDEN);
-			RNA_def_property_enum_items(prop_codec, ogg_codec_items);
-			RNA_enum_set(op->ptr, "format", AUD_FORMAT_S16);
-			break;
-		case AUD_CONTAINER_WAV:
-			RNA_def_property_flag(prop_bitrate, PROP_HIDDEN);
-			RNA_def_property_clear_flag(prop_format, PROP_HIDDEN);
-			RNA_def_property_enum_items(prop_format, pcm_format_items);
-			RNA_def_property_enum_items(prop_codec, all_codec_items);
-			RNA_enum_set(op->ptr, "codec", AUD_CODEC_PCM);
-			break;
-		default:
-			break;
-	}
-
-	RNA_pointer_create(&wm->id, op->type->srna, op->properties, &ptr);
-
-	/* main draw call */
-	uiDefAutoButsRNA(layout, &ptr, sound_mixdown_draw_check_prop, NULL, NULL, UI_BUT_LABEL_ALIGN_NONE, false);
+  static const EnumPropertyItem pcm_format_items[] = {
+      {AUD_FORMAT_U8, "U8", 0, "U8", "8 bit unsigned"},
+      {AUD_FORMAT_S16, "S16", 0, "S16", "16 bit signed"},
+#  ifdef WITH_SNDFILE
+      {AUD_FORMAT_S24, "S24", 0, "S24", "24 bit signed"},
+#  endif
+      {AUD_FORMAT_S32, "S32", 0, "S32", "32 bit signed"},
+      {AUD_FORMAT_FLOAT32, "F32", 0, "F32", "32 bit floating point"},
+      {AUD_FORMAT_FLOAT64, "F64", 0, "F64", "64 bit floating point"},
+      {0, NULL, 0, NULL, NULL},
+  };
+
+  static const EnumPropertyItem mp3_format_items[] = {
+      {AUD_FORMAT_S16, "S16", 0, "S16", "16 bit signed"},
+      {AUD_FORMAT_S32, "S32", 0, "S32", "32 bit signed"},
+      {0, NULL, 0, NULL, NULL},
+  };
+
+#  ifdef WITH_SNDFILE
+  static const EnumPropertyItem flac_format_items[] = {
+      {AUD_FORMAT_S16, "S16", 0, "S16", "16 bit signed"},
+      {AUD_FORMAT_S24, "S24", 0, "S24", "24 bit signed"},
+      {0, NULL, 0, NULL, NULL},
+  };
+#  endif
+
+  static const EnumPropertyItem all_codec_items[] = {
+      {AUD_CODEC_AAC, "AAC", 0, "AAC", "Advanced Audio Coding"},
+      {AUD_CODEC_AC3, "AC3", 0, "AC3", "Dolby Digital ATRAC 3"},
+      {AUD_CODEC_FLAC, "FLAC", 0, "FLAC", "Free Lossless Audio Codec"},
+      {AUD_CODEC_MP2, "MP2", 0, "MP2", "MPEG-1 Audio Layer II"},
+      {AUD_CODEC_MP3, "MP3", 0, "MP3", "MPEG-2 Audio Layer III"},
+      {AUD_CODEC_PCM, "PCM", 0, "PCM", "Pulse Code Modulation (RAW)"},
+      {AUD_CODEC_VORBIS, "VORBIS", 0, "Vorbis", "Xiph.Org Vorbis Codec"},
+      {0, NULL, 0, NULL, NULL},
+  };
+
+  static const EnumPropertyItem ogg_codec_items[] = {
+      {AUD_CODEC_FLAC, "FLAC", 0, "FLAC", "Free Lossless Audio Codec"},
+      {AUD_CODEC_VORBIS, "VORBIS", 0, "Vorbis", "Xiph.Org Vorbis Codec"},
+      {0, NULL, 0, NULL, NULL},
+  };
+
+  uiLayout *layout = op->layout;
+  wmWindowManager *wm = CTX_wm_manager(C);
+  PointerRNA ptr;
+  PropertyRNA *prop_format;
+  PropertyRNA *prop_codec;
+  PropertyRNA *prop_bitrate;
+
+  AUD_Container container = RNA_enum_get(op->ptr, "container");
+  AUD_Codec codec = RNA_enum_get(op->ptr, "codec");
+
+  prop_format = RNA_struct_find_property(op->ptr, "format");
+  prop_codec = RNA_struct_find_property(op->ptr, "codec");
+  prop_bitrate = RNA_struct_find_property(op->ptr, "bitrate");
+
+  RNA_def_property_clear_flag(prop_bitrate, PROP_HIDDEN);
+  RNA_def_property_flag(prop_codec, PROP_HIDDEN);
+  RNA_def_property_flag(prop_format, PROP_HIDDEN);
+
+  switch (container) {
+    case AUD_CONTAINER_AC3:
+      RNA_def_property_enum_items(prop_codec, all_codec_items);
+      RNA_enum_set(op->ptr, "codec", AUD_CODEC_AC3);
+      RNA_enum_set(op->ptr, "format", AUD_FORMAT_FLOAT32);
+      break;
+    case AUD_CONTAINER_FLAC:
+      RNA_def_property_flag(prop_bitrate, PROP_HIDDEN);
+      RNA_def_property_enum_items(prop_codec, all_codec_items);
+      RNA_enum_set(op->ptr, "codec", AUD_CODEC_FLAC);
+#  ifdef WITH_SNDFILE
+      RNA_def_property_clear_flag(prop_format, PROP_HIDDEN);
+      RNA_def_property_enum_items(prop_format, flac_format_items);
+#  else
+      RNA_enum_set(op->ptr, "format", AUD_FORMAT_S16);
+#  endif
+      break;
+    case AUD_CONTAINER_MATROSKA:
+      RNA_def_property_clear_flag(prop_codec, PROP_HIDDEN);
+      RNA_def_property_enum_items(prop_codec, all_codec_items);
+
+      switch (codec) {
+        case AUD_CODEC_AAC:
+          RNA_enum_set(op->ptr, "format", AUD_FORMAT_S16);
+          break;
+        case AUD_CODEC_AC3:
+          RNA_enum_set(op->ptr, "format", AUD_FORMAT_FLOAT32);
+          break;
+        case AUD_CODEC_FLAC:
+          RNA_def_property_flag(prop_bitrate, PROP_HIDDEN);
+          RNA_enum_set(op->ptr, "format", AUD_FORMAT_S16);
+          break;
+        case AUD_CODEC_MP2:
+          RNA_enum_set(op->ptr, "format", AUD_FORMAT_S16);
+          break;
+        case AUD_CODEC_MP3:
+          RNA_def_property_enum_items(prop_format, mp3_format_items);
+          RNA_def_property_clear_flag(prop_format, PROP_HIDDEN);
+          break;
+        case AUD_CODEC_PCM:
+          RNA_def_property_flag(prop_bitrate, PROP_HIDDEN);
+          RNA_def_property_enum_items(prop_format, pcm_format_items);
+          RNA_def_property_clear_flag(prop_format, PROP_HIDDEN);
+          break;
+        case AUD_CODEC_VORBIS:
+          RNA_enum_set(op->ptr, "format", AUD_FORMAT_S16);
+          break;
+        default:
+          break;
+      }
+
+      break;
+    case AUD_CONTAINER_MP2:
+      RNA_enum_set(op->ptr, "format", AUD_FORMAT_S16);
+      RNA_enum_set(op->ptr, "codec", AUD_CODEC_MP2);
+      RNA_def_property_enum_items(prop_codec, all_codec_items);
+      break;
+    case AUD_CONTAINER_MP3:
+      RNA_def_property_clear_flag(prop_format, PROP_HIDDEN);
+      RNA_def_property_enum_items(prop_format, mp3_format_items);
+      RNA_def_property_enum_items(prop_codec, all_codec_items);
+      RNA_enum_set(op->ptr, "codec", AUD_CODEC_MP3);
+      break;
+    case AUD_CONTAINER_OGG:
+      RNA_def_property_clear_flag(prop_codec, PROP_HIDDEN);
+      RNA_def_property_enum_items(prop_codec, ogg_codec_items);
+      RNA_enum_set(op->ptr, "format", AUD_FORMAT_S16);
+      break;
+    case AUD_CONTAINER_WAV:
+      RNA_def_property_flag(prop_bitrate, PROP_HIDDEN);
+      RNA_def_property_clear_flag(prop_format, PROP_HIDDEN);
+      RNA_def_property_enum_items(prop_format, pcm_format_items);
+      RNA_def_property_enum_items(prop_codec, all_codec_items);
+      RNA_enum_set(op->ptr, "codec", AUD_CODEC_PCM);
+      break;
+    default:
+      break;
+  }
+
+  RNA_pointer_create(&wm->id, op->type->srna, op->properties, &ptr);
+
+  /* main draw call */
+  uiDefAutoButsRNA(
+      layout, &ptr, sound_mixdown_draw_check_prop, NULL, NULL, UI_BUT_LABEL_ALIGN_NONE, false);
 }
-#endif // WITH_AUDASPACE
+#endif  // WITH_AUDASPACE
 
 static void SOUND_OT_mixdown(wmOperatorType *ot)
 {
 #ifdef WITH_AUDASPACE
-	static const EnumPropertyItem format_items[] = {
-		{AUD_FORMAT_U8, "U8", 0, "U8", "8 bit unsigned"},
-		{AUD_FORMAT_S16, "S16", 0, "S16", "16 bit signed"},
-		{AUD_FORMAT_S24, "S24", 0, "S24", "24 bit signed"},
-		{AUD_FORMAT_S32, "S32", 0, "S32", "32 bit signed"},
-		{AUD_FORMAT_FLOAT32, "F32", 0, "F32", "32 bit floating point"},
-		{AUD_FORMAT_FLOAT64, "F64", 0, "F64", "64 bit floating point"},
-		{0, NULL, 0, NULL, NULL},
-	};
-
-	static const EnumPropertyItem codec_items[] = {
-#ifdef WITH_FFMPEG
-		{AUD_CODEC_AAC, "AAC", 0, "AAC", "Advanced Audio Coding"},
-		{AUD_CODEC_AC3, "AC3", 0, "AC3", "Dolby Digital ATRAC 3"},
-#endif
-		{AUD_CODEC_FLAC, "FLAC", 0, "FLAC", "Free Lossless Audio Codec"},
-#ifdef WITH_FFMPEG
-		{AUD_CODEC_MP2, "MP2", 0, "MP2", "MPEG-1 Audio Layer II"},
-		{AUD_CODEC_MP3, "MP3", 0, "MP3", "MPEG-2 Audio Layer III"},
-#endif
-		{AUD_CODEC_PCM, "PCM", 0, "PCM", "Pulse Code Modulation (RAW)"},
-		{AUD_CODEC_VORBIS, "VORBIS", 0, "Vorbis", "Xiph.Org Vorbis Codec"},
-		{0, NULL, 0, NULL, NULL},
-	};
-
-#endif // WITH_AUDASPACE
-
-	/* identifiers */
-	ot->name = "Mixdown";
-	ot->description = "Mix the scene's audio to a sound file";
-	ot->idname = "SOUND_OT_mixdown";
-
-	/* api callbacks */
-	ot->exec = sound_mixdown_exec;
-	ot->invoke = sound_mixdown_invoke;
+  static const EnumPropertyItem format_items[] = {
+      {AUD_FORMAT_U8, "U8", 0, "U8", "8 bit unsigned"},
+      {AUD_FORMAT_S16, "S16", 0, "S16", "16 bit signed"},
+      {AUD_FORMAT_S24, "S24", 0, "S24", "24 bit signed"},
+      {AUD_FORMAT_S32, "S32", 0, "S32", "32 bit signed"},
+      {AUD_FORMAT_FLOAT32, "F32", 0, "F32", "32 bit floating point"},
+      {AUD_FORMAT_FLOAT64, "F64", 0, "F64", "64 bit floating point"},
+      {0, NULL, 0, NULL, NULL},
+  };
+
+  static const EnumPropertyItem codec_items[] = {
+#  ifdef WITH_FFMPEG
+      {AUD_CODEC_AAC, "AAC", 0, "AAC", "Advanced Audio Coding"},
+      {AUD_CODEC_AC3, "AC3", 0, "AC3", "Dolby Digital ATRAC 3"},
+#  endif
+      {AUD_CODEC_FLAC, "FLAC", 0, "FLAC", "Free Lossless Audio Codec"},
+#  ifdef WITH_FFMPEG
+      {AUD_CODEC_MP2, "MP2", 0, "MP2", "MPEG-1 Audio Layer II"},
+      {AUD_CODEC_MP3, "MP3", 0, "MP3", "MPEG-2 Audio Layer III"},
+#  endif
+      {AUD_CODEC_PCM, "PCM", 0, "PCM", "Pulse Code Modulation (RAW)"},
+      {AUD_CODEC_VORBIS, "VORBIS", 0, "Vorbis", "Xiph.Org Vorbis Codec"},
+      {0, NULL, 0, NULL, NULL},
+  };
+
+#endif  // WITH_AUDASPACE
+
+  /* identifiers */
+  ot->name = "Mixdown";
+  ot->description = "Mix the scene's audio to a sound file";
+  ot->idname = "SOUND_OT_mixdown";
+
+  /* api callbacks */
+  ot->exec = sound_mixdown_exec;
+  ot->invoke = sound_mixdown_invoke;
 
 #ifdef WITH_AUDASPACE
-	ot->check = sound_mixdown_check;
-	ot->ui = sound_mixdown_draw;
+  ot->check = sound_mixdown_check;
+  ot->ui = sound_mixdown_draw;
 #endif
-	/* flags */
-	ot->flag = OPTYPE_REGISTER;
-
-	/* properties */
-	WM_operator_properties_filesel(
-	        ot, FILE_TYPE_FOLDER | FILE_TYPE_SOUND, FILE_SPECIAL, FILE_SAVE,
-	        WM_FILESEL_FILEPATH | WM_FILESEL_RELPATH, FILE_DEFAULTDISPLAY, FILE_SORT_ALPHA);
+  /* flags */
+  ot->flag = OPTYPE_REGISTER;
+
+  /* properties */
+  WM_operator_properties_filesel(ot,
+                                 FILE_TYPE_FOLDER | FILE_TYPE_SOUND,
+                                 FILE_SPECIAL,
+                                 FILE_SAVE,
+                                 WM_FILESEL_FILEPATH | WM_FILESEL_RELPATH,
+                                 FILE_DEFAULTDISPLAY,
+                                 FILE_SORT_ALPHA);
 #ifdef WITH_AUDASPACE
-	RNA_def_int(ot->srna, "accuracy", 1024, 1, 16777216, "Accuracy",
-	            "Sample accuracy, important for animation data (the lower the value, the more accurate)",
-	            1, 16777216);
-	RNA_def_enum(ot->srna, "container", container_items, AUD_CONTAINER_FLAC, "Container", "File format");
-	RNA_def_enum(ot->srna, "codec", codec_items, AUD_CODEC_FLAC, "Codec", "Audio Codec");
-	RNA_def_enum(ot->srna, "format", format_items, AUD_FORMAT_S16, "Format", "Sample format");
-	RNA_def_int(ot->srna, "bitrate", 192, 32, 512, "Bitrate", "Bitrate in kbit/s", 32, 512);
-	RNA_def_boolean(ot->srna, "split_channels", 0, "Split channels", "Each channel will be rendered into a mono file");
-#endif // WITH_AUDASPACE
+  RNA_def_int(
+      ot->srna,
+      "accuracy",
+      1024,
+      1,
+      16777216,
+      "Accuracy",
+      "Sample accuracy, important for animation data (the lower the value, the more accurate)",
+      1,
+      16777216);
+  RNA_def_enum(
+      ot->srna, "container", container_items, AUD_CONTAINER_FLAC, "Container", "File format");
+  RNA_def_enum(ot->srna, "codec", codec_items, AUD_CODEC_FLAC, "Codec", "Audio Codec");
+  RNA_def_enum(ot->srna, "format", format_items, AUD_FORMAT_S16, "Format", "Sample format");
+  RNA_def_int(ot->srna, "bitrate", 192, 32, 512, "Bitrate", "Bitrate in kbit/s", 32, 512);
+  RNA_def_boolean(ot->srna,
+                  "split_channels",
+                  0,
+                  "Split channels",
+                  "Each channel will be rendered into a mono file");
+#endif  // WITH_AUDASPACE
 }
 
 /* ******************************************************* */
 
 static bool sound_poll(bContext *C)
 {
-	Editing *ed = CTX_data_scene(C)->ed;
+  Editing *ed = CTX_data_scene(C)->ed;
 
-	if (!ed || !ed->act_seq || ed->act_seq->type != SEQ_TYPE_SOUND_RAM)
-		return 0;
+  if (!ed || !ed->act_seq || ed->act_seq->type != SEQ_TYPE_SOUND_RAM)
+    return 0;
 
-	return 1;
+  return 1;
 }
 /********************* pack operator *********************/
 
 static int sound_pack_exec(bContext *C, wmOperator *op)
 {
-	Main *bmain = CTX_data_main(C);
-	Editing *ed = CTX_data_scene(C)->ed;
-	bSound *sound;
+  Main *bmain = CTX_data_main(C);
+  Editing *ed = CTX_data_scene(C)->ed;
+  bSound *sound;
 
-	if (!ed || !ed->act_seq || ed->act_seq->type != SEQ_TYPE_SOUND_RAM)
-		return OPERATOR_CANCELLED;
+  if (!ed || !ed->act_seq || ed->act_seq->type != SEQ_TYPE_SOUND_RAM)
+    return OPERATOR_CANCELLED;
 
-	sound = ed->act_seq->sound;
+  sound = ed->act_seq->sound;
 
-	if (!sound || sound->packedfile)
-		return OPERATOR_CANCELLED;
+  if (!sound || sound->packedfile)
+    return OPERATOR_CANCELLED;
 
-	sound->packedfile = newPackedFile(op->reports, sound->name, ID_BLEND_PATH(bmain, &sound->id));
-	BKE_sound_load(bmain, sound);
+  sound->packedfile = newPackedFile(op->reports, sound->name, ID_BLEND_PATH(bmain, &sound->id));
+  BKE_sound_load(bmain, sound);
 
-	return OPERATOR_FINISHED;
+  return OPERATOR_FINISHED;
 }
 
 static void SOUND_OT_pack(wmOperatorType *ot)
 {
-	/* identifiers */
-	ot->name = "Pack Sound";
-	ot->description = "Pack the sound into the current blend file";
-	ot->idname = "SOUND_OT_pack";
+  /* identifiers */
+  ot->name = "Pack Sound";
+  ot->description = "Pack the sound into the current blend file";
+  ot->idname = "SOUND_OT_pack";
 
-	/* api callbacks */
-	ot->exec = sound_pack_exec;
-	ot->poll = sound_poll;
+  /* api callbacks */
+  ot->exec = sound_pack_exec;
+  ot->poll = sound_poll;
 
-	/* flags */
-	ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+  /* flags */
+  ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 }
 
 /********************* unpack operator *********************/
 
 static int sound_unpack_exec(bContext *C, wmOperator *op)
 {
-	Main *bmain = CTX_data_main(C);
-	int method = RNA_enum_get(op->ptr, "method");
-	bSound *sound = NULL;
+  Main *bmain = CTX_data_main(C);
+  int method = RNA_enum_get(op->ptr, "method");
+  bSound *sound = NULL;
 
-	/* find the suppplied image by name */
-	if (RNA_struct_property_is_set(op->ptr, "id")) {
-		char sndname[MAX_ID_NAME - 2];
-		RNA_string_get(op->ptr, "id", sndname);
-		sound = BLI_findstring(&bmain->sounds, sndname, offsetof(ID, name) + 2);
-	}
+  /* find the suppplied image by name */
+  if (RNA_struct_property_is_set(op->ptr, "id")) {
+    char sndname[MAX_ID_NAME - 2];
+    RNA_string_get(op->ptr, "id", sndname);
+    sound = BLI_findstring(&bmain->sounds, sndname, offsetof(ID, name) + 2);
+  }
 
-	if (!sound || !sound->packedfile)
-		return OPERATOR_CANCELLED;
+  if (!sound || !sound->packedfile)
+    return OPERATOR_CANCELLED;
 
-	if (G.fileflags & G_FILE_AUTOPACK)
-		BKE_report(op->reports, RPT_WARNING, "AutoPack is enabled, so image will be packed again on file save");
+  if (G.fileflags & G_FILE_AUTOPACK)
+    BKE_report(op->reports,
+               RPT_WARNING,
+               "AutoPack is enabled, so image will be packed again on file save");
 
-	unpackSound(bmain, op->reports, sound, method);
+  unpackSound(bmain, op->reports, sound, method);
 
-	return OPERATOR_FINISHED;
+  return OPERATOR_FINISHED;
 }
 
 static int sound_unpack_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
 {
-	Editing *ed = CTX_data_scene(C)->ed;
-	bSound *sound;
+  Editing *ed = CTX_data_scene(C)->ed;
+  bSound *sound;
 
-	if (RNA_struct_property_is_set(op->ptr, "id"))
-		return sound_unpack_exec(C, op);
+  if (RNA_struct_property_is_set(op->ptr, "id"))
+    return sound_unpack_exec(C, op);
 
-	if (!ed || !ed->act_seq || ed->act_seq->type != SEQ_TYPE_SOUND_RAM)
-		return OPERATOR_CANCELLED;
+  if (!ed || !ed->act_seq || ed->act_seq->type != SEQ_TYPE_SOUND_RAM)
+    return OPERATOR_CANCELLED;
 
-	sound = ed->act_seq->sound;
+  sound = ed->act_seq->sound;
 
-	if (!sound || !sound->packedfile)
-		return OPERATOR_CANCELLED;
+  if (!sound || !sound->packedfile)
+    return OPERATOR_CANCELLED;
 
-	if (G.fileflags & G_FILE_AUTOPACK)
-		BKE_report(op->reports, RPT_WARNING, "AutoPack is enabled, so image will be packed again on file save");
+  if (G.fileflags & G_FILE_AUTOPACK)
+    BKE_report(op->reports,
+               RPT_WARNING,
+               "AutoPack is enabled, so image will be packed again on file save");
 
-	unpack_menu(C, "SOUND_OT_unpack", sound->id.name + 2, sound->name, "sounds", sound->packedfile);
+  unpack_menu(C, "SOUND_OT_unpack", sound->id.name + 2, sound->name, "sounds", sound->packedfile);
 
-	return OPERATOR_FINISHED;
+  return OPERATOR_FINISHED;
 }
 
 static void SOUND_OT_unpack(wmOperatorType *ot)
 {
-	/* identifiers */
-	ot->name = "Unpack Sound";
-	ot->description = "Unpack the sound to the samples filename";
-	ot->idname = "SOUND_OT_unpack";
-
-	/* api callbacks */
-	ot->exec = sound_unpack_exec;
-	ot->invoke = sound_unpack_invoke;
-	ot->poll = sound_poll;
-
-	/* flags */
-	ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
-
-	/* properties */
-	RNA_def_enum(ot->srna, "method", rna_enum_unpack_method_items, PF_USE_LOCAL, "Method", "How to unpack");
-	/* XXX, weark!, will fail with library, name collisions */
-	RNA_def_string(ot->srna, "id", NULL, MAX_ID_NAME - 2, "Sound Name", "Sound data-block name to unpack");
+  /* identifiers */
+  ot->name = "Unpack Sound";
+  ot->description = "Unpack the sound to the samples filename";
+  ot->idname = "SOUND_OT_unpack";
+
+  /* api callbacks */
+  ot->exec = sound_unpack_exec;
+  ot->invoke = sound_unpack_invoke;
+  ot->poll = sound_poll;
+
+  /* flags */
+  ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+
+  /* properties */
+  RNA_def_enum(
+      ot->srna, "method", rna_enum_unpack_method_items, PF_USE_LOCAL, "Method", "How to unpack");
+  /* XXX, weark!, will fail with library, name collisions */
+  RNA_def_string(
+      ot->srna, "id", NULL, MAX_ID_NAME - 2, "Sound Name", "Sound data-block name to unpack");
 }
 
 /* ******************************************************* */
 
 void ED_operatortypes_sound(void)
 {
-	WM_operatortype_append(SOUND_OT_open);
-	WM_operatortype_append(SOUND_OT_open_mono);
-	WM_operatortype_append(SOUND_OT_mixdown);
-	WM_operatortype_append(SOUND_OT_pack);
-	WM_operatortype_append(SOUND_OT_unpack);
-	WM_operatortype_append(SOUND_OT_update_animation_flags);
-	WM_operatortype_append(SOUND_OT_bake_animation);
+  WM_operatortype_append(SOUND_OT_open);
+  WM_operatortype_append(SOUND_OT_open_mono);
+  WM_operatortype_append(SOUND_OT_mixdown);
+  WM_operatortype_append(SOUND_OT_pack);
+  WM_operatortype_append(SOUND_OT_unpack);
+  WM_operatortype_append(SOUND_OT_update_animation_flags);
+  WM_operatortype_append(SOUND_OT_bake_animation);
 }