sound module: Append functions with BKE (makes it easier to make them

out from local functions)

6 files changed, 119 insertions, 119 deletions

diff --git a/source/blender/blenkernel/BKE_sound.h b/source/blender/blenkernel/BKE_sound.h
index a4182b8405f..3570751165c 100644
--- a/source/blender/blenkernel/BKE_sound.h
+++ b/source/blender/blenkernel/BKE_sound.h
@@ -46,19 +46,19 @@ typedef struct SoundWaveform {
 	float *data;
 } SoundWaveform;
 
-void sound_init_once(void);
-void sound_exit_once(void);
+void BKE_sound_init_once(void);
+void BKE_sound_exit_once(void);
 
-void sound_init(struct Main *main);
+void BKE_sound_init(struct Main *main);
 
-void sound_init_main(struct Main *bmain);
+void BKE_sound_init_main(struct Main *bmain);
 
-void sound_exit(void);
+void BKE_sound_exit(void);
 
-void sound_force_device(int device);
-int sound_define_from_str(const char *str);
+void BKE_sound_force_device(int device);
+int BKE_sound_define_from_str(const char *str);
 
-struct bSound *sound_new_file(struct Main *main, const char *filename);
+struct bSound *BKE_sound_new_file(struct Main *main, const char *filename);
 
 // XXX unused currently
 #if 0
@@ -67,13 +67,13 @@ struct bSound *sound_new_buffer(struct Main *bmain, struct bSound *source);
 struct bSound *sound_new_limiter(struct Main *bmain, struct bSound *source, float start, float end);
 #endif
 
-void sound_delete(struct Main *bmain, struct bSound *sound);
+void BKE_sound_delete(struct Main *bmain, struct bSound *sound);
 
-void sound_cache(struct bSound *sound);
+void BKE_sound_cache(struct bSound *sound);
 
-void sound_delete_cache(struct bSound *sound);
+void BKE_sound_delete_cache(struct bSound *sound);
 
-void sound_load(struct Main *main, struct bSound *sound);
+void BKE_sound_load(struct Main *main, struct bSound *sound);
 
 void BKE_sound_free(struct bSound *sound);
 
@@ -81,63 +81,63 @@ void BKE_sound_free(struct bSound *sound);
 AUD_Device *sound_mixdown(struct Scene *scene, AUD_DeviceSpecs specs, int start, float volume);
 #endif
 
-void sound_create_scene(struct Scene *scene);
+void BKE_sound_create_scene(struct Scene *scene);
 
-void sound_destroy_scene(struct Scene *scene);
+void BKE_sound_destroy_scene(struct Scene *scene);
 
-void sound_mute_scene(struct Scene *scene, int muted);
+void BKE_sound_mute_scene(struct Scene *scene, int muted);
 
-void sound_update_fps(struct Scene *scene);
+void BKE_sound_update_fps(struct Scene *scene);
 
-void sound_update_scene_listener(struct Scene *scene);
+void BKE_sound_update_scene_listener(struct Scene *scene);
 
-void *sound_scene_add_scene_sound(struct Scene *scene, struct Sequence *sequence, int startframe, int endframe, int frameskip);
-void *sound_scene_add_scene_sound_defaults(struct Scene *scene, struct Sequence *sequence);
+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_defaults(struct Scene *scene, struct Sequence *sequence);
 
-void *sound_add_scene_sound(struct Scene *scene, struct Sequence *sequence, int startframe, int endframe, int frameskip);
-void *sound_add_scene_sound_defaults(struct Scene *scene, struct Sequence *sequence);
+void *BKE_sound_add_scene_sound(struct Scene *scene, struct Sequence *sequence, int startframe, int endframe, int frameskip);
+void *BKE_sound_add_scene_sound_defaults(struct Scene *scene, struct Sequence *sequence);
 
-void sound_remove_scene_sound(struct Scene *scene, void *handle);
+void BKE_sound_remove_scene_sound(struct Scene *scene, void *handle);
 
-void sound_mute_scene_sound(void *handle, char mute);
+void BKE_sound_mute_scene_sound(void *handle, char mute);
 
-void sound_move_scene_sound(struct Scene *scene, void *handle, int startframe, int endframe, int frameskip);
-void sound_move_scene_sound_defaults(struct Scene *scene, struct Sequence *sequence);
+void BKE_sound_move_scene_sound(struct Scene *scene, void *handle, int startframe, int endframe, int frameskip);
+void BKE_sound_move_scene_sound_defaults(struct Scene *scene, struct Sequence *sequence);
 
-void sound_update_scene_sound(void *handle, struct bSound *sound);
+void BKE_sound_update_scene_sound(void *handle, struct bSound *sound);
 
-void sound_set_cfra(int cfra);
+void BKE_sound_set_cfra(int cfra);
 
-void sound_set_scene_volume(struct Scene *scene, float volume);
+void BKE_sound_set_scene_volume(struct Scene *scene, float volume);
 
-void sound_set_scene_sound_volume(void *handle, float volume, char animated);
+void BKE_sound_set_scene_sound_volume(void *handle, float volume, char animated);
 
-void sound_set_scene_sound_pitch(void *handle, float pitch, char animated);
+void BKE_sound_set_scene_sound_pitch(void *handle, float pitch, char animated);
 
-void sound_set_scene_sound_pan(void *handle, float pan, char animated);
+void BKE_sound_set_scene_sound_pan(void *handle, float pan, char animated);
 
-void sound_update_sequencer(struct Main *main, struct bSound *sound);
+void BKE_sound_update_sequencer(struct Main *main, struct bSound *sound);
 
-void sound_play_scene(struct Scene *scene);
+void BKE_sound_play_scene(struct Scene *scene);
 
-void sound_stop_scene(struct Scene *scene);
+void BKE_sound_stop_scene(struct Scene *scene);
 
-void sound_seek_scene(struct Main *bmain, struct Scene *scene);
+void BKE_sound_seek_scene(struct Main *bmain, struct Scene *scene);
 
-float sound_sync_scene(struct Scene *scene);
+float BKE_sound_sync_scene(struct Scene *scene);
 
-int sound_scene_playing(struct Scene *scene);
+int BKE_sound_scene_playing(struct Scene *scene);
 
-void sound_free_waveform(struct bSound *sound);
+void BKE_sound_free_waveform(struct bSound *sound);
 
-void sound_read_waveform(struct bSound *sound, short *stop);
+void BKE_sound_read_waveform(struct bSound *sound, short *stop);
 
-void sound_update_scene(struct Main *bmain, struct Scene *scene);
+void BKE_sound_update_scene(struct Main *bmain, struct Scene *scene);
 
-void *sound_get_factory(void *sound);
+void *BKE_sound_get_factory(void *sound);
 
-float sound_get_length(struct bSound *sound);
+float BKE_sound_get_length(struct bSound *sound);
 
-bool sound_is_jack_supported(void);
+bool BKE_sound_is_jack_supported(void);
 
 #endif  /* __BKE_SOUND_H__ */
diff --git a/source/blender/blenkernel/intern/blender.c b/source/blender/blenkernel/intern/blender.c
index b6ea780576e..c7b306521c4 100644
--- a/source/blender/blenkernel/intern/blender.c
+++ b/source/blender/blenkernel/intern/blender.c
@@ -305,7 +305,7 @@ static void setup_app_data(bContext *C, BlendFileData *bfd, const char *filepath
 
 	CTX_data_main_set(C, G.main);
 
-	sound_init_main(G.main);
+	BKE_sound_init_main(G.main);
 	
 	if (bfd->user) {
 		
diff --git a/source/blender/blenkernel/intern/packedFile.c b/source/blender/blenkernel/intern/packedFile.c
index 8d56b1247fe..9b429b356b4 100644
--- a/source/blender/blenkernel/intern/packedFile.c
+++ b/source/blender/blenkernel/intern/packedFile.c
@@ -553,7 +553,7 @@ int unpackSound(Main *bmain, ReportList *reports, bSound *sound, int how)
 			freePackedFile(sound->packedfile);
 			sound->packedfile = NULL;
 
-			sound_load(bmain, sound);
+			BKE_sound_load(bmain, sound);
 
 			ret_value = RET_OK;
 		}
diff --git a/source/blender/blenkernel/intern/scene.c b/source/blender/blenkernel/intern/scene.c
index d2c3f473e11..f51dadf1da6 100644
--- a/source/blender/blenkernel/intern/scene.c
+++ b/source/blender/blenkernel/intern/scene.c
@@ -293,7 +293,7 @@ Scene *BKE_scene_copy(Scene *sce, int type)
 	}
 	
 	/* before scene copy */
-	sound_create_scene(scen);
+	BKE_sound_create_scene(scen);
 
 	/* world */
 	if (type == SCE_COPY_FULL) {
@@ -426,7 +426,7 @@ void BKE_scene_free(Scene *sce)
 	if (sce->fps_info)
 		MEM_freeN(sce->fps_info);
 
-	sound_destroy_scene(sce);
+	BKE_sound_destroy_scene(sce);
 
 	BKE_color_managed_view_settings_free(&sce->view_settings);
 }
@@ -682,7 +682,7 @@ Scene *BKE_scene_add(Main *bmain, const char *name)
 
 	sce->gm.exitkey = 218; // Blender key code for ESC
 
-	sound_create_scene(sce);
+	BKE_sound_create_scene(sce);
 
 	/* color management */
 	colorspace_name = IMB_colormanagement_role_colorspace_name_get(COLOR_ROLE_DEFAULT_SEQUENCER);
@@ -1690,7 +1690,7 @@ void BKE_scene_update_tagged(EvaluationContext *eval_ctx, Main *bmain, Scene *sc
 	 * only objects and scenes. - brecht */
 	scene_update_tagged_recursive(eval_ctx, bmain, scene, scene);
 	/* update sound system animation (TODO, move to depsgraph) */
-	sound_update_scene(bmain, scene);
+	BKE_sound_update_scene(bmain, scene);
 
 	/* extra call here to recalc scene animation (for sequencer) */
 	{
@@ -1769,7 +1769,7 @@ void BKE_scene_update_for_newframe_ex(EvaluationContext *eval_ctx, Main *bmain,
 	 */
 	scene_rebuild_rbw_recursive(sce, ctime);
 
-	sound_set_cfra(sce->r.cfra);
+	BKE_sound_set_cfra(sce->r.cfra);
 	
 	/* clear animation overrides */
 	/* XXX TODO... */
@@ -1814,7 +1814,7 @@ void BKE_scene_update_for_newframe_ex(EvaluationContext *eval_ctx, Main *bmain,
 	/* BKE_object_handle_update() on all objects, groups and sets */
 	scene_update_tagged_recursive(eval_ctx, bmain, sce, sce);
 	/* update sound system animation (TODO, move to depsgraph) */
-	sound_update_scene(bmain, sce);
+	BKE_sound_update_scene(bmain, sce);
 
 	scene_depsgraph_hack(eval_ctx, sce, sce);
 
diff --git a/source/blender/blenkernel/intern/sequencer.c b/source/blender/blenkernel/intern/sequencer.c
index eb7736fff30..6fa39e8bbe0 100644
--- a/source/blender/blenkernel/intern/sequencer.c
+++ b/source/blender/blenkernel/intern/sequencer.c
@@ -205,7 +205,7 @@ static void BKE_sequence_free_ex(Scene *scene, Sequence *seq, const bool do_cach
 			ed->act_seq = NULL;
 
 		if (seq->scene_sound && ELEM(seq->type, SEQ_TYPE_SOUND_RAM, SEQ_TYPE_SCENE))
-			sound_remove_scene_sound(scene, seq->scene_sound);
+			BKE_sound_remove_scene_sound(scene, seq->scene_sound);
 
 		seq_free_animdata(scene, seq);
 	}
@@ -316,7 +316,7 @@ static void seqclipboard_ptr_restore(Main *bmain, ID **id_pt)
 				{
 					id_restore = BLI_findstring(lb, ((bSound *)ID_PT)->name, offsetof(bSound, name));
 					if (id_restore == NULL) {
-						id_restore = sound_new_file(bmain, ((bSound *)ID_PT)->name);
+						id_restore = BKE_sound_new_file(bmain, ((bSound *)ID_PT)->name);
 						(ID_PT)->newid = id_restore;  /* reuse next time */
 					}
 					break;
@@ -652,7 +652,7 @@ static void seq_update_sound_bounds_recursive_rec(Scene *scene, Sequence *metase
 				if (seq->start + seq->len - seq->endofs > end)
 					endofs = seq->start + seq->len - end;
 
-				sound_move_scene_sound(scene, seq->scene_sound, seq->start + startofs,
+				BKE_sound_move_scene_sound(scene, seq->scene_sound, seq->start + startofs,
 				                       seq->start + seq->len - endofs, startofs + seq->anim_startofs);
 			}
 		}
@@ -3747,10 +3747,10 @@ void BKE_sequence_sound_init(Scene *scene, Sequence *seq)
 	}
 	else {
 		if (seq->sound) {
-			seq->scene_sound = sound_add_scene_sound_defaults(scene, seq);
+			seq->scene_sound = BKE_sound_add_scene_sound_defaults(scene, seq);
 		}
 		if (seq->scene) {
-			seq->scene_sound = sound_scene_add_scene_sound_defaults(scene, seq);
+			seq->scene_sound = BKE_sound_scene_add_scene_sound_defaults(scene, seq);
 		}
 	}
 }
@@ -3962,11 +3962,11 @@ void BKE_sequencer_update_sound_bounds(Scene *scene, Sequence *seq)
 			/* We have to take into account start frame of the sequence's scene! */
 			int startofs = seq->startofs + seq->anim_startofs + seq->scene->r.sfra;
 
-			sound_move_scene_sound(scene, seq->scene_sound, seq->startdisp, seq->enddisp, startofs);
+			BKE_sound_move_scene_sound(scene, seq->scene_sound, seq->startdisp, seq->enddisp, startofs);
 		}
 	}
 	else {
-		sound_move_scene_sound_defaults(scene, seq);
+		BKE_sound_move_scene_sound_defaults(scene, seq);
 	}
 	/* mute is set in seq_update_muting_recursive */
 }
@@ -3991,7 +3991,7 @@ static void seq_update_muting_recursive(ListBase *seqbasep, Sequence *metaseq, i
 		}
 		else if (ELEM(seq->type, SEQ_TYPE_SOUND_RAM, SEQ_TYPE_SCENE)) {
 			if (seq->scene_sound) {
-				sound_mute_scene_sound(seq->scene_sound, seqmute);
+				BKE_sound_mute_scene_sound(seq->scene_sound, seqmute);
 			}
 		}
 	}
@@ -4020,7 +4020,7 @@ static void seq_update_sound_recursive(Scene *scene, ListBase *seqbasep, bSound
 		}
 		else if (seq->type == SEQ_TYPE_SOUND_RAM) {
 			if (seq->scene_sound && sound == seq->sound) {
-				sound_update_scene_sound(seq->scene_sound, sound);
+				BKE_sound_update_scene_sound(seq->scene_sound, sound);
 			}
 		}
 	}
@@ -4353,7 +4353,7 @@ static void seq_load_apply(Scene *scene, Sequence *seq, SeqLoadInfo *seq_load)
 
 		if (seq_load->flag & SEQ_LOAD_SOUND_CACHE) {
 			if (seq->sound)
-				sound_cache(seq->sound);
+				BKE_sound_cache(seq->sound);
 		}
 
 		seq_load->tot_success++;
@@ -4459,7 +4459,7 @@ Sequence *BKE_sequencer_add_sound_strip(bContext *C, ListBase *seqbasep, SeqLoad
 
 	AUD_SoundInfo info;
 
-	sound = sound_new_file(bmain, seq_load->path); /* handles relative paths */
+	sound = BKE_sound_new_file(bmain, seq_load->path); /* handles relative paths */
 
 	if (sound == NULL || sound->playback_handle == NULL) {
 #if 0
@@ -4473,7 +4473,7 @@ Sequence *BKE_sequencer_add_sound_strip(bContext *C, ListBase *seqbasep, SeqLoad
 	info = AUD_getInfo(sound->playback_handle);
 
 	if (info.specs.channels == AUD_CHANNELS_INVALID) {
-		sound_delete(bmain, sound);
+		BKE_sound_delete(bmain, sound);
 #if 0
 		if (op)
 			BKE_report(op->reports, RPT_ERROR, "Unsupported audio format");
@@ -4498,7 +4498,7 @@ Sequence *BKE_sequencer_add_sound_strip(bContext *C, ListBase *seqbasep, SeqLoad
 
 	BLI_split_dirfile(seq_load->path, strip->dir, se->name, sizeof(strip->dir), sizeof(se->name));
 
-	seq->scene_sound = sound_add_scene_sound(scene, seq, seq_load->start_frame, seq_load->start_frame + seq->len, 0);
+	seq->scene_sound = BKE_sound_add_scene_sound(scene, seq, seq_load->start_frame, seq_load->start_frame + seq->len, 0);
 
 	BKE_sequence_calc_disp(scene, seq);
 
@@ -4620,7 +4620,7 @@ static Sequence *seq_dupli(Scene *scene, Scene *scene_to, Sequence *seq, int dup
 	else if (seq->type == SEQ_TYPE_SCENE) {
 		seqn->strip->stripdata = NULL;
 		if (seq->scene_sound)
-			seqn->scene_sound = sound_scene_add_scene_sound_defaults(sce_audio, seqn);
+			seqn->scene_sound = BKE_sound_scene_add_scene_sound_defaults(sce_audio, seqn);
 	}
 	else if (seq->type == SEQ_TYPE_MOVIECLIP) {
 		/* avoid assert */
@@ -4637,7 +4637,7 @@ static Sequence *seq_dupli(Scene *scene, Scene *scene_to, Sequence *seq, int dup
 		seqn->strip->stripdata =
 		        MEM_dupallocN(seq->strip->stripdata);
 		if (seq->scene_sound)
-			seqn->scene_sound = sound_add_scene_sound_defaults(sce_audio, seqn);
+			seqn->scene_sound = BKE_sound_add_scene_sound_defaults(sce_audio, seqn);
 
 		id_us_plus((ID *)seqn->sound);
 	}
diff --git a/source/blender/blenkernel/intern/sound.c b/source/blender/blenkernel/intern/sound.c
index b9d70664874..cc0d0bdcfcc 100644
--- a/source/blender/blenkernel/intern/sound.c
+++ b/source/blender/blenkernel/intern/sound.c
@@ -64,7 +64,7 @@
 static int sound_cfra;
 #endif
 
-bSound *sound_new_file(struct Main *bmain, const char *filename)
+bSound *BKE_sound_new_file(struct Main *bmain, const char *filename)
 {
 	bSound *sound = NULL;
 
@@ -87,7 +87,7 @@ bSound *sound_new_file(struct Main *bmain, const char *filename)
 	BLI_strncpy(sound->name, filename, FILE_MAX);
 	/* sound->type = SOUND_TYPE_FILE; */ /* XXX unused currently */
 
-	sound_load(bmain, sound);
+	BKE_sound_load(bmain, sound);
 
 	if (!sound->playback_handle) {
 		BKE_libblock_free(bmain, sound);
@@ -116,7 +116,7 @@ void BKE_sound_free(bSound *sound)
 		sound->cache = NULL;
 	}
 
-	sound_free_waveform(sound);
+	BKE_sound_free_waveform(sound);
 	
 	if (sound->spinlock) {
 		BLI_spin_end(sound->spinlock);
@@ -152,7 +152,7 @@ static void sound_sync_callback(void *data, int mode, float time)
 }
 #endif
 
-int sound_define_from_str(const char *str)
+int BKE_sound_define_from_str(const char *str)
 {
 	if (BLI_strcaseeq(str, "NULL"))
 		return AUD_NULL_DEVICE;
@@ -166,18 +166,18 @@ int sound_define_from_str(const char *str)
 	return -1;
 }
 
-void sound_force_device(int device)
+void BKE_sound_force_device(int device)
 {
 	force_device = device;
 }
 
-void sound_init_once(void)
+void BKE_sound_init_once(void)
 {
 	AUD_initOnce();
-	atexit(sound_exit_once);
+	atexit(BKE_sound_exit_once);
 }
 
-void sound_init(struct Main *bmain)
+void BKE_sound_init(struct Main *bmain)
 {
 	AUD_DeviceSpecs specs;
 	int device, buffersize;
@@ -206,10 +206,10 @@ void sound_init(struct Main *bmain)
 	if (!AUD_init(device, specs, buffersize))
 		AUD_init(AUD_NULL_DEVICE, specs, buffersize);
 
-	sound_init_main(bmain);
+	BKE_sound_init_main(bmain);
 }
 
-void sound_init_main(struct Main *bmain)
+void BKE_sound_init_main(struct Main *bmain)
 {
 #ifdef WITH_JACK
 	AUD_setSyncCallback(sound_sync_callback, bmain);
@@ -218,12 +218,12 @@ void sound_init_main(struct Main *bmain)
 #endif
 }
 
-void sound_exit(void)
+void BKE_sound_exit(void)
 {
 	AUD_exit();
 }
 
-void sound_exit_once(void)
+void BKE_sound_exit_once(void)
 {
 	AUD_exit();
 	AUD_exitOnce();
@@ -282,7 +282,7 @@ bSound *sound_new_limiter(struct Main *bmain, bSound *source, float start, float
 }
 #endif
 
-void sound_delete(struct Main *bmain, bSound *sound)
+void BKE_sound_delete(struct Main *bmain, bSound *sound)
 {
 	if (sound) {
 		BKE_sound_free(sound);
@@ -291,7 +291,7 @@ void sound_delete(struct Main *bmain, bSound *sound)
 	}
 }
 
-void sound_cache(bSound *sound)
+void BKE_sound_cache(bSound *sound)
 {
 	sound->flags |= SOUND_FLAGS_CACHING;
 	if (sound->cache)
@@ -304,7 +304,7 @@ void sound_cache(bSound *sound)
 		sound->playback_handle = sound->handle;
 }
 
-void sound_delete_cache(bSound *sound)
+void BKE_sound_delete_cache(bSound *sound)
 {
 	sound->flags &= ~SOUND_FLAGS_CACHING;
 	if (sound->cache) {
@@ -314,7 +314,7 @@ void sound_delete_cache(bSound *sound)
 	}
 }
 
-void sound_load(struct Main *bmain, bSound *sound)
+void BKE_sound_load(struct Main *bmain, bSound *sound)
 {
 	if (sound) {
 		if (sound->cache) {
@@ -328,7 +328,7 @@ void sound_load(struct Main *bmain, bSound *sound)
 			sound->playback_handle = NULL;
 		}
 
-		sound_free_waveform(sound);
+		BKE_sound_free_waveform(sound);
 
 /* XXX unused currently */
 #if 0
@@ -382,7 +382,7 @@ void sound_load(struct Main *bmain, bSound *sound)
 		else
 			sound->playback_handle = sound->handle;
 
-		sound_update_sequencer(bmain, sound);
+		BKE_sound_update_sequencer(bmain, sound);
 	}
 }
 
@@ -391,7 +391,7 @@ AUD_Device *sound_mixdown(struct Scene *scene, AUD_DeviceSpecs specs, int start,
 	return AUD_openMixdownDevice(specs, scene->sound_scene, volume, start / FPS);
 }
 
-void sound_create_scene(struct Scene *scene)
+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)
@@ -405,7 +405,7 @@ void sound_create_scene(struct Scene *scene)
 	scene->speaker_handles = NULL;
 }
 
-void sound_destroy_scene(struct Scene *scene)
+void BKE_sound_destroy_scene(struct Scene *scene)
 {
 	if (scene->sound_scene_handle)
 		AUD_stop(scene->sound_scene_handle);
@@ -417,13 +417,13 @@ void sound_destroy_scene(struct Scene *scene)
 		AUD_destroySet(scene->speaker_handles);
 }
 
-void sound_mute_scene(struct Scene *scene, int muted)
+void BKE_sound_mute_scene(struct Scene *scene, int muted)
 {
 	if (scene->sound_scene)
 		AUD_setSequencerMuted(scene->sound_scene, muted);
 }
 
-void sound_update_fps(struct Scene *scene)
+void BKE_sound_update_fps(struct Scene *scene)
 {
 	if (scene->sound_scene)
 		AUD_setSequencerFPS(scene->sound_scene, FPS);
@@ -431,13 +431,13 @@ void sound_update_fps(struct Scene *scene)
 	BKE_sequencer_refresh_sound_length(scene);
 }
 
-void sound_update_scene_listener(struct Scene *scene)
+void BKE_sound_update_scene_listener(struct Scene *scene)
 {
 	AUD_updateSequencerData(scene->sound_scene, scene->audio.speed_of_sound,
 	                        scene->audio.doppler_factor, scene->audio.distance_model);
 }
 
-void *sound_scene_add_scene_sound(struct Scene *scene, struct Sequence *sequence,
+void *BKE_sound_scene_add_scene_sound(struct Scene *scene, struct Sequence *sequence,
                                   int startframe, int endframe, int frameskip)
 {
 	if (scene != sequence->scene) {
@@ -448,14 +448,14 @@ void *sound_scene_add_scene_sound(struct Scene *scene, struct Sequence *sequence
 	return NULL;
 }
 
-void *sound_scene_add_scene_sound_defaults(struct Scene *scene, struct Sequence *sequence)
+void *BKE_sound_scene_add_scene_sound_defaults(struct Scene *scene, struct Sequence *sequence)
 {
-	return sound_scene_add_scene_sound(scene, sequence,
+	return BKE_sound_scene_add_scene_sound(scene, sequence,
 	                                   sequence->startdisp, sequence->enddisp,
 	                                   sequence->startofs + sequence->anim_startofs);
 }
 
-void *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)
 {
 	const double fps = FPS;
 	void *handle = AUD_addSequence(scene->sound_scene, sequence->sound->playback_handle,
@@ -467,70 +467,70 @@ void *sound_add_scene_sound(struct Scene *scene, struct Sequence *sequence, int
 	return handle;
 }
 
-void *sound_add_scene_sound_defaults(struct Scene *scene, struct Sequence *sequence)
+void *BKE_sound_add_scene_sound_defaults(struct Scene *scene, struct Sequence *sequence)
 {
-	return sound_add_scene_sound(scene, sequence,
+	return BKE_sound_add_scene_sound(scene, sequence,
 	                             sequence->startdisp, sequence->enddisp,
 	                             sequence->startofs + sequence->anim_startofs);
 }
 
-void sound_remove_scene_sound(struct Scene *scene, void *handle)
+void BKE_sound_remove_scene_sound(struct Scene *scene, void *handle)
 {
 	AUD_removeSequence(scene->sound_scene, handle);
 }
 
-void sound_mute_scene_sound(void *handle, char mute)
+void BKE_sound_mute_scene_sound(void *handle, char mute)
 {
 	AUD_muteSequence(handle, mute);
 }
 
-void 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_moveSequence(handle, startframe / fps, endframe / fps, frameskip / fps);
 }
 
-void sound_move_scene_sound_defaults(struct Scene *scene, struct Sequence *sequence)
+void BKE_sound_move_scene_sound_defaults(struct Scene *scene, struct Sequence *sequence)
 {
 	if (sequence->scene_sound) {
-		sound_move_scene_sound(scene, sequence->scene_sound,
+		BKE_sound_move_scene_sound(scene, sequence->scene_sound,
 		                       sequence->startdisp, sequence->enddisp,
 		                       sequence->startofs + sequence->anim_startofs);
 	}
 }
 
-void sound_update_scene_sound(void *handle, bSound *sound)
+void BKE_sound_update_scene_sound(void *handle, bSound *sound)
 {
 	AUD_updateSequenceSound(handle, sound->playback_handle);
 }
 
-void sound_set_cfra(int cfra)
+void BKE_sound_set_cfra(int cfra)
 {
 	sound_cfra = cfra;
 }
 
-void sound_set_scene_volume(struct Scene *scene, float volume)
+void BKE_sound_set_scene_volume(struct Scene *scene, float volume)
 {
 	AUD_setSequencerAnimData(scene->sound_scene, AUD_AP_VOLUME, CFRA, &volume,
 	                         (scene->audio.flag & AUDIO_VOLUME_ANIMATED) != 0);
 }
 
-void sound_set_scene_sound_volume(void *handle, float volume, char animated)
+void BKE_sound_set_scene_sound_volume(void *handle, float volume, char animated)
 {
 	AUD_setSequenceAnimData(handle, AUD_AP_VOLUME, sound_cfra, &volume, animated);
 }
 
-void sound_set_scene_sound_pitch(void *handle, float pitch, char animated)
+void BKE_sound_set_scene_sound_pitch(void *handle, float pitch, char animated)
 {
 	AUD_setSequenceAnimData(handle, AUD_AP_PITCH, sound_cfra, &pitch, animated);
 }
 
-void sound_set_scene_sound_pan(void *handle, float pan, char animated)
+void BKE_sound_set_scene_sound_pan(void *handle, float pan, char animated)
 {
 	AUD_setSequenceAnimData(handle, AUD_AP_PANNING, sound_cfra, &pan, animated);
 }
 
-void sound_update_sequencer(struct Main *main, bSound *sound)
+void BKE_sound_update_sequencer(struct Main *main, bSound *sound)
 {
 	struct Scene *scene;
 
@@ -550,7 +550,7 @@ static void sound_start_play_scene(struct Scene *scene)
 		AUD_setLoop(scene->sound_scene_handle, -1);
 }
 
-void sound_play_scene(struct Scene *scene)
+void BKE_sound_play_scene(struct Scene *scene)
 {
 	AUD_Status status;
 	const float cur_time = (float)((double)CFRA / FPS);
@@ -579,7 +579,7 @@ void sound_play_scene(struct Scene *scene)
 	AUD_unlock();
 }
 
-void sound_stop_scene(struct Scene *scene)
+void BKE_sound_stop_scene(struct Scene *scene)
 {
 	if (scene->sound_scene_handle) {
 		AUD_pause(scene->sound_scene_handle);
@@ -589,7 +589,7 @@ void sound_stop_scene(struct Scene *scene)
 	}
 }
 
-void sound_seek_scene(struct Main *bmain, struct Scene *scene)
+void BKE_sound_seek_scene(struct Main *bmain, struct Scene *scene)
 {
 	AUD_Status status;
 	bScreen *screen;
@@ -654,7 +654,7 @@ void sound_seek_scene(struct Main *bmain, struct Scene *scene)
 	AUD_unlock();
 }
 
-float sound_sync_scene(struct Scene *scene)
+float BKE_sound_sync_scene(struct Scene *scene)
 {
 	if (scene->sound_scene_handle) {
 		if (scene->audio.flag & AUDIO_SYNC)
@@ -665,7 +665,7 @@ float sound_sync_scene(struct Scene *scene)
 	return NAN_FLT;
 }
 
-int sound_scene_playing(struct Scene *scene)
+int BKE_sound_scene_playing(struct Scene *scene)
 {
 	if (scene->audio.flag & AUDIO_SYNC)
 		return AUD_doesPlayback();
@@ -673,7 +673,7 @@ int sound_scene_playing(struct Scene *scene)
 		return -1;
 }
 
-void sound_free_waveform(bSound *sound)
+void BKE_sound_free_waveform(bSound *sound)
 {
 	SoundWaveform *waveform = sound->waveform;
 	if (waveform) {
@@ -686,7 +686,7 @@ void sound_free_waveform(bSound *sound)
 	sound->waveform = NULL;
 }
 
-void sound_read_waveform(bSound *sound, short *stop)
+void BKE_sound_read_waveform(bSound *sound, short *stop)
 {
 	AUD_SoundInfo info = AUD_getInfo(sound->playback_handle);
 	SoundWaveform *waveform = MEM_mallocN(sizeof(SoundWaveform), "SoundWaveform");
@@ -717,7 +717,7 @@ void sound_read_waveform(bSound *sound, short *stop)
 		return;
 	}
 		
-	sound_free_waveform(sound);
+	BKE_sound_free_waveform(sound);
 	
 	BLI_spin_lock(sound->spinlock);
 	sound->waveform = waveform;
@@ -725,7 +725,7 @@ void sound_read_waveform(bSound *sound, short *stop)
 	BLI_spin_unlock(sound->spinlock);
 }
 
-void sound_update_scene(Main *bmain, struct Scene *scene)
+void BKE_sound_update_scene(Main *bmain, struct Scene *scene)
 {
 	Object *ob;
 	Base *base;
@@ -806,20 +806,20 @@ void sound_update_scene(Main *bmain, struct Scene *scene)
 	scene->speaker_handles = new_set;
 }
 
-void *sound_get_factory(void *sound)
+void *BKE_sound_get_factory(void *sound)
 {
 	return ((bSound *)sound)->playback_handle;
 }
 
 /* stupid wrapper because AUD_C-API.h includes Python.h which makesrna doesn't like */
-float sound_get_length(bSound *sound)
+float BKE_sound_get_length(bSound *sound)
 {
 	AUD_SoundInfo info = AUD_getInfo(sound->playback_handle);
 
 	return info.length;
 }
 
-bool sound_is_jack_supported(void)
+bool BKE_sound_is_jack_supported(void)
 {
 	return (bool)AUD_isJackSupported();
 }