Cleanup: style, use braces for blenkernel
[blender.git] / source / blender / blenkernel / intern / sound.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup bke
22  */
23
24 #include <string.h>
25 #include <stdlib.h>
26
27 #include "MEM_guardedalloc.h"
28
29 #include "BLI_blenlib.h"
30 #include "BLI_math.h"
31 #include "BLI_threads.h"
32
33 #include "DNA_anim_types.h"
34 #include "DNA_object_types.h"
35 #include "DNA_scene_types.h"
36 #include "DNA_sequence_types.h"
37 #include "DNA_packedFile_types.h"
38 #include "DNA_screen_types.h"
39 #include "DNA_sound_types.h"
40 #include "DNA_speaker_types.h"
41
42 #ifdef WITH_AUDASPACE
43 #  include <AUD_Sound.h>
44 #  include <AUD_Sequence.h>
45 #  include <AUD_Handle.h>
46 #  include <AUD_Special.h>
47 #  include "../../../intern/audaspace/intern/AUD_Set.h"
48 #endif
49
50 #include "BKE_global.h"
51 #include "BKE_main.h"
52 #include "BKE_sound.h"
53 #include "BKE_library.h"
54 #include "BKE_packedFile.h"
55 #include "BKE_sequencer.h"
56 #include "BKE_scene.h"
57
58 #ifdef WITH_AUDASPACE
59 /* evil globals ;-) */
60 static int sound_cfra;
61 static char **audio_device_names = NULL;
62 #endif
63
64 bSound *BKE_sound_new_file(struct Main *bmain, const char *filepath)
65 {
66   bSound *sound;
67   const char *path;
68   char str[FILE_MAX];
69
70   BLI_strncpy(str, filepath, sizeof(str));
71
72   path = BKE_main_blendfile_path(bmain);
73
74   BLI_path_abs(str, path);
75
76   sound = BKE_libblock_alloc(bmain, ID_SO, BLI_path_basename(filepath), 0);
77   BLI_strncpy(sound->name, filepath, FILE_MAX);
78   /* sound->type = SOUND_TYPE_FILE; */ /* XXX unused currently */
79
80   BKE_sound_load(bmain, sound);
81
82   return sound;
83 }
84
85 bSound *BKE_sound_new_file_exists_ex(struct Main *bmain, const char *filepath, bool *r_exists)
86 {
87   bSound *sound;
88   char str[FILE_MAX], strtest[FILE_MAX];
89
90   BLI_strncpy(str, filepath, sizeof(str));
91   BLI_path_abs(str, BKE_main_blendfile_path(bmain));
92
93   /* first search an identical filepath */
94   for (sound = bmain->sounds.first; sound; sound = sound->id.next) {
95     BLI_strncpy(strtest, sound->name, sizeof(sound->name));
96     BLI_path_abs(strtest, ID_BLEND_PATH(bmain, &sound->id));
97
98     if (BLI_path_cmp(strtest, str) == 0) {
99       id_us_plus(&sound->id); /* officially should not, it doesn't link here! */
100       if (r_exists) {
101         *r_exists = true;
102       }
103       return sound;
104     }
105   }
106
107   if (r_exists) {
108     *r_exists = false;
109   }
110   return BKE_sound_new_file(bmain, filepath);
111 }
112
113 bSound *BKE_sound_new_file_exists(struct Main *bmain, const char *filepath)
114 {
115   return BKE_sound_new_file_exists_ex(bmain, filepath, NULL);
116 }
117
118 /** Free (or release) any data used by this sound (does not free the sound itself). */
119 void BKE_sound_free(bSound *sound)
120 {
121   /* No animdata here. */
122
123   if (sound->packedfile) {
124     freePackedFile(sound->packedfile);
125     sound->packedfile = NULL;
126   }
127
128 #ifdef WITH_AUDASPACE
129   if (sound->handle) {
130     AUD_Sound_free(sound->handle);
131     sound->handle = NULL;
132     sound->playback_handle = NULL;
133   }
134
135   if (sound->cache) {
136     AUD_Sound_free(sound->cache);
137     sound->cache = NULL;
138   }
139
140   BKE_sound_free_waveform(sound);
141
142 #endif /* WITH_AUDASPACE */
143   if (sound->spinlock) {
144     BLI_spin_end(sound->spinlock);
145     MEM_freeN(sound->spinlock);
146     sound->spinlock = NULL;
147   }
148 }
149
150 /**
151  * Only copy internal data of Sound ID from source to already allocated/initialized destination.
152  * You probably never want to use that directly, use BKE_id_copy or BKE_id_copy_ex for typical needs.
153  *
154  * WARNING! This function will not handle ID user count!
155  *
156  * \param flag: Copying options (see BKE_library.h's LIB_ID_COPY_... flags for more).
157  */
158 void BKE_sound_copy_data(Main *bmain,
159                          bSound *sound_dst,
160                          const bSound *UNUSED(sound_src),
161                          const int UNUSED(flag))
162 {
163   sound_dst->handle = NULL;
164   sound_dst->cache = NULL;
165   sound_dst->waveform = NULL;
166   sound_dst->playback_handle = NULL;
167   sound_dst->spinlock =
168       NULL; /* Think this is OK? Otherwise, easy to create new spinlock here... */
169
170   /* Just to be sure, should not have any value actually after reading time. */
171   sound_dst->ipo = NULL;
172   sound_dst->newpackedfile = NULL;
173
174   if (sound_dst->packedfile) {
175     sound_dst->packedfile = dupPackedFile(sound_dst->packedfile);
176   }
177
178   /* Initialize whole runtime (audaspace) stuff. */
179   BKE_sound_load(bmain, sound_dst);
180 }
181
182 void BKE_sound_make_local(Main *bmain, bSound *sound, const bool lib_local)
183 {
184   BKE_id_make_local_generic(bmain, &sound->id, true, lib_local);
185 }
186
187 #ifdef WITH_AUDASPACE
188
189 static const char *force_device = NULL;
190
191 #  ifdef WITH_JACK
192 static void sound_sync_callback(void *data, int mode, float time)
193 {
194   // Ugly: Blender doesn't like it when the animation is played back during rendering
195   if (G.is_rendering) {
196     return;
197   }
198
199   struct Main *bmain = (struct Main *)data;
200   struct Scene *scene;
201
202   scene = bmain->scenes.first;
203   while (scene) {
204     if (scene->audio.flag & AUDIO_SYNC) {
205       if (mode) {
206         BKE_sound_play_scene(scene);
207       }
208       else {
209         BKE_sound_stop_scene(scene);
210       }
211       if (scene->playback_handle) {
212         AUD_Handle_setPosition(scene->playback_handle, time);
213       }
214     }
215     scene = scene->id.next;
216   }
217 }
218 #  endif
219
220 void BKE_sound_force_device(const char *device)
221 {
222   force_device = device;
223 }
224
225 void BKE_sound_init_once(void)
226 {
227   AUD_initOnce();
228   atexit(BKE_sound_exit_once);
229 }
230
231 static AUD_Device *sound_device = NULL;
232
233 void *BKE_sound_get_device(void)
234 {
235   return sound_device;
236 }
237
238 void BKE_sound_init(struct Main *bmain)
239 {
240   /* Make sure no instance of the sound system is running, otherwise we get leaks. */
241   BKE_sound_exit();
242
243   AUD_DeviceSpecs specs;
244   int device, buffersize;
245   const char *device_name;
246
247   device = U.audiodevice;
248   buffersize = U.mixbufsize;
249   specs.channels = U.audiochannels;
250   specs.format = U.audioformat;
251   specs.rate = U.audiorate;
252
253   if (force_device == NULL) {
254     int i;
255     char **names = BKE_sound_get_device_names();
256     device_name = names[0];
257
258     /* make sure device is within the bounds of the array */
259     for (i = 0; names[i]; i++) {
260       if (i == device) {
261         device_name = names[i];
262       }
263     }
264   }
265   else {
266     device_name = force_device;
267   }
268
269   if (buffersize < 128) {
270     buffersize = 1024;
271   }
272
273   if (specs.rate < AUD_RATE_8000) {
274     specs.rate = AUD_RATE_48000;
275   }
276
277   if (specs.format <= AUD_FORMAT_INVALID) {
278     specs.format = AUD_FORMAT_S16;
279   }
280
281   if (specs.channels <= AUD_CHANNELS_INVALID) {
282     specs.channels = AUD_CHANNELS_STEREO;
283   }
284
285   if (!(sound_device = AUD_init(device_name, specs, buffersize, "Blender"))) {
286     sound_device = AUD_init("Null", specs, buffersize, "Blender");
287   }
288
289   BKE_sound_init_main(bmain);
290 }
291
292 void BKE_sound_init_main(struct Main *bmain)
293 {
294 #  ifdef WITH_JACK
295   if (sound_device) {
296     AUD_setSynchronizerCallback(sound_sync_callback, bmain);
297   }
298 #  else
299   (void)bmain; /* unused */
300 #  endif
301 }
302
303 void BKE_sound_exit(void)
304 {
305   AUD_exit(sound_device);
306   sound_device = NULL;
307 }
308
309 void BKE_sound_exit_once(void)
310 {
311   AUD_exit(sound_device);
312   sound_device = NULL;
313   AUD_exitOnce();
314
315   if (audio_device_names != NULL) {
316     int i;
317     for (i = 0; audio_device_names[i]; i++) {
318       free(audio_device_names[i]);
319     }
320     free(audio_device_names);
321     audio_device_names = NULL;
322   }
323 }
324
325 /* XXX unused currently */
326 #  if 0
327 bSound *BKE_sound_new_buffer(struct Main *bmain, bSound *source)
328 {
329   bSound *sound = NULL;
330
331   char name[MAX_ID_NAME + 5];
332   strcpy(name, "buf_");
333   strcpy(name + 4, source->id.name);
334
335   sound = BKE_libblock_alloc(bmain, ID_SO, name);
336
337   sound->child_sound = source;
338   sound->type = SOUND_TYPE_BUFFER;
339
340   sound_load(bmain, sound);
341
342   return sound;
343 }
344
345 bSound *BKE_sound_new_limiter(struct Main *bmain, bSound *source, float start, float end)
346 {
347   bSound *sound = NULL;
348
349   char name[MAX_ID_NAME + 5];
350   strcpy(name, "lim_");
351   strcpy(name + 4, source->id.name);
352
353   sound = BKE_libblock_alloc(bmain, ID_SO, name);
354
355   sound->child_sound = source;
356   sound->start = start;
357   sound->end = end;
358   sound->type = SOUND_TYPE_LIMITER;
359
360   sound_load(bmain, sound);
361
362   return sound;
363 }
364 #  endif
365
366 void BKE_sound_cache(bSound *sound)
367 {
368   sound->flags |= SOUND_FLAGS_CACHING;
369   if (sound->cache) {
370     AUD_Sound_free(sound->cache);
371   }
372
373   sound->cache = AUD_Sound_cache(sound->handle);
374   if (sound->cache) {
375     sound->playback_handle = sound->cache;
376   }
377   else {
378     sound->playback_handle = sound->handle;
379   }
380 }
381
382 void BKE_sound_delete_cache(bSound *sound)
383 {
384   sound->flags &= ~SOUND_FLAGS_CACHING;
385   if (sound->cache) {
386     AUD_Sound_free(sound->cache);
387     sound->cache = NULL;
388     sound->playback_handle = sound->handle;
389   }
390 }
391
392 void BKE_sound_load(struct Main *bmain, bSound *sound)
393 {
394   if (sound) {
395     if (sound->cache) {
396       AUD_Sound_free(sound->cache);
397       sound->cache = NULL;
398     }
399
400     if (sound->handle) {
401       AUD_Sound_free(sound->handle);
402       sound->handle = NULL;
403       sound->playback_handle = NULL;
404     }
405
406     BKE_sound_free_waveform(sound);
407
408 /* XXX unused currently */
409 #  if 0
410     switch (sound->type) {
411       case SOUND_TYPE_FILE:
412 #  endif
413     {
414       char fullpath[FILE_MAX];
415
416       /* load sound */
417       PackedFile *pf = sound->packedfile;
418
419       /* don't modify soundact->sound->name, only change a copy */
420       BLI_strncpy(fullpath, sound->name, sizeof(fullpath));
421       BLI_path_abs(fullpath, ID_BLEND_PATH(bmain, &sound->id));
422
423       /* but we need a packed file then */
424       if (pf) {
425         sound->handle = AUD_Sound_bufferFile((unsigned char *)pf->data, pf->size);
426       }
427       else {
428         /* or else load it from disk */
429         sound->handle = AUD_Sound_file(fullpath);
430       }
431     }
432 /* XXX unused currently */
433 #  if 0
434       break;
435     }
436     case SOUND_TYPE_BUFFER:
437       if (sound->child_sound && sound->child_sound->handle) {
438         sound->handle = AUD_bufferSound(sound->child_sound->handle);
439       }
440       break;
441     case SOUND_TYPE_LIMITER:
442       if (sound->child_sound && sound->child_sound->handle) {
443         sound->handle = AUD_limitSound(sound->child_sound, sound->start, sound->end);
444       }
445       break;
446   }
447 #  endif
448     if (sound->flags & SOUND_FLAGS_MONO) {
449       void *handle = AUD_Sound_rechannel(sound->handle, AUD_CHANNELS_MONO);
450       AUD_Sound_free(sound->handle);
451       sound->handle = handle;
452     }
453
454     if (sound->flags & SOUND_FLAGS_CACHING) {
455       sound->cache = AUD_Sound_cache(sound->handle);
456     }
457
458     if (sound->cache) {
459       sound->playback_handle = sound->cache;
460     }
461     else {
462       sound->playback_handle = sound->handle;
463     }
464
465     BKE_sound_update_sequencer(bmain, sound);
466   }
467 }
468
469 AUD_Device *BKE_sound_mixdown(struct Scene *scene, AUD_DeviceSpecs specs, int start, float volume)
470 {
471   return AUD_openMixdownDevice(specs, scene->sound_scene, volume, start / FPS);
472 }
473
474 void BKE_sound_create_scene(struct Scene *scene)
475 {
476   /* should be done in version patch, but this gets called before */
477   if (scene->r.frs_sec_base == 0) {
478     scene->r.frs_sec_base = 1;
479   }
480
481   scene->sound_scene = AUD_Sequence_create(FPS, scene->audio.flag & AUDIO_MUTE);
482   AUD_Sequence_setSpeedOfSound(scene->sound_scene, scene->audio.speed_of_sound);
483   AUD_Sequence_setDopplerFactor(scene->sound_scene, scene->audio.doppler_factor);
484   AUD_Sequence_setDistanceModel(scene->sound_scene, scene->audio.distance_model);
485   scene->playback_handle = NULL;
486   scene->sound_scrub_handle = NULL;
487   scene->speaker_handles = NULL;
488 }
489
490 void BKE_sound_destroy_scene(struct Scene *scene)
491 {
492   if (scene->playback_handle) {
493     AUD_Handle_stop(scene->playback_handle);
494   }
495   if (scene->sound_scrub_handle) {
496     AUD_Handle_stop(scene->sound_scrub_handle);
497   }
498   if (scene->sound_scene) {
499     AUD_Sequence_free(scene->sound_scene);
500   }
501   if (scene->speaker_handles) {
502     AUD_destroySet(scene->speaker_handles);
503   }
504 }
505
506 void BKE_sound_reset_scene_specs(struct Scene *scene)
507 {
508   AUD_Specs specs;
509
510   specs.channels = AUD_Device_getChannels(sound_device);
511   specs.rate = AUD_Device_getRate(sound_device);
512
513   AUD_Sequence_setSpecs(scene->sound_scene, specs);
514 }
515
516 void BKE_sound_mute_scene(struct Scene *scene, int muted)
517 {
518   if (scene->sound_scene) {
519     AUD_Sequence_setMuted(scene->sound_scene, muted);
520   }
521 }
522
523 void BKE_sound_update_fps(struct Scene *scene)
524 {
525   if (scene->sound_scene) {
526     AUD_Sequence_setFPS(scene->sound_scene, FPS);
527   }
528
529   BKE_sequencer_refresh_sound_length(scene);
530 }
531
532 void BKE_sound_update_scene_listener(struct Scene *scene)
533 {
534   AUD_Sequence_setSpeedOfSound(scene->sound_scene, scene->audio.speed_of_sound);
535   AUD_Sequence_setDopplerFactor(scene->sound_scene, scene->audio.doppler_factor);
536   AUD_Sequence_setDistanceModel(scene->sound_scene, scene->audio.distance_model);
537 }
538
539 void *BKE_sound_scene_add_scene_sound(
540     struct Scene *scene, struct Sequence *sequence, int startframe, int endframe, int frameskip)
541 {
542   if (sequence->scene && scene != sequence->scene) {
543     const double fps = FPS;
544     return AUD_Sequence_add(scene->sound_scene,
545                             sequence->scene->sound_scene,
546                             startframe / fps,
547                             endframe / fps,
548                             frameskip / fps);
549   }
550   return NULL;
551 }
552
553 void *BKE_sound_scene_add_scene_sound_defaults(struct Scene *scene, struct Sequence *sequence)
554 {
555   return BKE_sound_scene_add_scene_sound(scene,
556                                          sequence,
557                                          sequence->startdisp,
558                                          sequence->enddisp,
559                                          sequence->startofs + sequence->anim_startofs);
560 }
561
562 void *BKE_sound_add_scene_sound(
563     struct Scene *scene, struct Sequence *sequence, int startframe, int endframe, int frameskip)
564 {
565   /* Happens when sequence's sound datablock was removed. */
566   if (sequence->sound == NULL) {
567     return NULL;
568   }
569   const double fps = FPS;
570   void *handle = AUD_Sequence_add(scene->sound_scene,
571                                   sequence->sound->playback_handle,
572                                   startframe / fps,
573                                   endframe / fps,
574                                   frameskip / fps);
575   AUD_SequenceEntry_setMuted(handle, (sequence->flag & SEQ_MUTE) != 0);
576   AUD_SequenceEntry_setAnimationData(handle, AUD_AP_VOLUME, CFRA, &sequence->volume, 0);
577   AUD_SequenceEntry_setAnimationData(handle, AUD_AP_PITCH, CFRA, &sequence->pitch, 0);
578   AUD_SequenceEntry_setAnimationData(handle, AUD_AP_PANNING, CFRA, &sequence->pan, 0);
579   return handle;
580 }
581
582 void *BKE_sound_add_scene_sound_defaults(struct Scene *scene, struct Sequence *sequence)
583 {
584   return BKE_sound_add_scene_sound(scene,
585                                    sequence,
586                                    sequence->startdisp,
587                                    sequence->enddisp,
588                                    sequence->startofs + sequence->anim_startofs);
589 }
590
591 void BKE_sound_remove_scene_sound(struct Scene *scene, void *handle)
592 {
593   AUD_Sequence_remove(scene->sound_scene, handle);
594 }
595
596 void BKE_sound_mute_scene_sound(void *handle, char mute)
597 {
598   AUD_SequenceEntry_setMuted(handle, mute);
599 }
600
601 void BKE_sound_move_scene_sound(
602     struct Scene *scene, void *handle, int startframe, int endframe, int frameskip)
603 {
604   const double fps = FPS;
605   AUD_SequenceEntry_move(handle, startframe / fps, endframe / fps, frameskip / fps);
606 }
607
608 void BKE_sound_move_scene_sound_defaults(struct Scene *scene, struct Sequence *sequence)
609 {
610   if (sequence->scene_sound) {
611     BKE_sound_move_scene_sound(scene,
612                                sequence->scene_sound,
613                                sequence->startdisp,
614                                sequence->enddisp,
615                                sequence->startofs + sequence->anim_startofs);
616   }
617 }
618
619 void BKE_sound_update_scene_sound(void *handle, bSound *sound)
620 {
621   AUD_SequenceEntry_setSound(handle, sound->playback_handle);
622 }
623
624 void BKE_sound_set_cfra(int cfra)
625 {
626   sound_cfra = cfra;
627 }
628
629 void BKE_sound_set_scene_volume(struct Scene *scene, float volume)
630 {
631   AUD_Sequence_setAnimationData(scene->sound_scene,
632                                 AUD_AP_VOLUME,
633                                 CFRA,
634                                 &volume,
635                                 (scene->audio.flag & AUDIO_VOLUME_ANIMATED) != 0);
636 }
637
638 void BKE_sound_set_scene_sound_volume(void *handle, float volume, char animated)
639 {
640   AUD_SequenceEntry_setAnimationData(handle, AUD_AP_VOLUME, sound_cfra, &volume, animated);
641 }
642
643 void BKE_sound_set_scene_sound_pitch(void *handle, float pitch, char animated)
644 {
645   AUD_SequenceEntry_setAnimationData(handle, AUD_AP_PITCH, sound_cfra, &pitch, animated);
646 }
647
648 void BKE_sound_set_scene_sound_pan(void *handle, float pan, char animated)
649 {
650   printf("%s\n", __func__);
651   AUD_SequenceEntry_setAnimationData(handle, AUD_AP_PANNING, sound_cfra, &pan, animated);
652 }
653
654 void BKE_sound_update_sequencer(struct Main *main, bSound *sound)
655 {
656   struct Scene *scene;
657
658   for (scene = main->scenes.first; scene; scene = scene->id.next) {
659     BKE_sequencer_update_sound(scene, sound);
660   }
661 }
662
663 static void sound_start_play_scene(struct Scene *scene)
664 {
665   if (scene->playback_handle) {
666     AUD_Handle_stop(scene->playback_handle);
667   }
668
669   BKE_sound_reset_scene_specs(scene);
670
671   if ((scene->playback_handle = AUD_Device_play(sound_device, scene->sound_scene, 1))) {
672     AUD_Handle_setLoopCount(scene->playback_handle, -1);
673   }
674 }
675
676 void BKE_sound_play_scene(struct Scene *scene)
677 {
678   AUD_Status status;
679   const float cur_time = (float)((double)CFRA / FPS);
680
681   AUD_Device_lock(sound_device);
682
683   status = scene->playback_handle ? AUD_Handle_getStatus(scene->playback_handle) :
684                                     AUD_STATUS_INVALID;
685
686   if (status == AUD_STATUS_INVALID) {
687     sound_start_play_scene(scene);
688
689     if (!scene->playback_handle) {
690       AUD_Device_unlock(sound_device);
691       return;
692     }
693   }
694
695   if (status != AUD_STATUS_PLAYING) {
696     AUD_Handle_setPosition(scene->playback_handle, cur_time);
697     AUD_Handle_resume(scene->playback_handle);
698   }
699
700   if (scene->audio.flag & AUDIO_SYNC) {
701     AUD_playSynchronizer();
702   }
703
704   AUD_Device_unlock(sound_device);
705 }
706
707 void BKE_sound_stop_scene(struct Scene *scene)
708 {
709   if (scene->playback_handle) {
710     AUD_Handle_pause(scene->playback_handle);
711
712     if (scene->audio.flag & AUDIO_SYNC) {
713       AUD_stopSynchronizer();
714     }
715   }
716 }
717
718 void BKE_sound_seek_scene(struct Main *bmain, struct Scene *scene)
719 {
720   AUD_Status status;
721   bScreen *screen;
722   int animation_playing;
723
724   const float one_frame = (float)(1.0 / FPS);
725   const float cur_time = (float)((double)CFRA / FPS);
726
727   AUD_Device_lock(sound_device);
728
729   status = scene->playback_handle ? AUD_Handle_getStatus(scene->playback_handle) :
730                                     AUD_STATUS_INVALID;
731
732   if (status == AUD_STATUS_INVALID) {
733     sound_start_play_scene(scene);
734
735     if (!scene->playback_handle) {
736       AUD_Device_unlock(sound_device);
737       return;
738     }
739
740     AUD_Handle_pause(scene->playback_handle);
741   }
742
743   animation_playing = 0;
744   for (screen = bmain->screens.first; screen; screen = screen->id.next) {
745     if (screen->animtimer) {
746       animation_playing = 1;
747       break;
748     }
749   }
750
751   if (scene->audio.flag & AUDIO_SCRUB && !animation_playing) {
752     AUD_Handle_setPosition(scene->playback_handle, cur_time);
753     if (scene->audio.flag & AUDIO_SYNC) {
754       AUD_seekSynchronizer(scene->playback_handle, cur_time);
755     }
756     AUD_Handle_resume(scene->playback_handle);
757     if (scene->sound_scrub_handle &&
758         AUD_Handle_getStatus(scene->sound_scrub_handle) != AUD_STATUS_INVALID) {
759       AUD_Handle_setPosition(scene->sound_scrub_handle, 0);
760     }
761     else {
762       if (scene->sound_scrub_handle) {
763         AUD_Handle_stop(scene->sound_scrub_handle);
764       }
765       scene->sound_scrub_handle = AUD_pauseAfter(scene->playback_handle, one_frame);
766     }
767   }
768   else {
769     if (scene->audio.flag & AUDIO_SYNC) {
770       AUD_seekSynchronizer(scene->playback_handle, cur_time);
771     }
772     else {
773       if (status == AUD_STATUS_PLAYING) {
774         AUD_Handle_setPosition(scene->playback_handle, cur_time);
775       }
776     }
777   }
778
779   AUD_Device_unlock(sound_device);
780 }
781
782 float BKE_sound_sync_scene(struct Scene *scene)
783 {
784   // Ugly: Blender doesn't like it when the animation is played back during rendering
785   if (G.is_rendering) {
786     return NAN_FLT;
787   }
788
789   if (scene->playback_handle) {
790     if (scene->audio.flag & AUDIO_SYNC) {
791       return AUD_getSynchronizerPosition(scene->playback_handle);
792     }
793     else {
794       return AUD_Handle_getPosition(scene->playback_handle);
795     }
796   }
797   return NAN_FLT;
798 }
799
800 int BKE_sound_scene_playing(struct Scene *scene)
801 {
802   // Ugly: Blender doesn't like it when the animation is played back during rendering
803   if (G.is_rendering) {
804     return -1;
805   }
806
807   if (scene->audio.flag & AUDIO_SYNC) {
808     return AUD_isSynchronizerPlaying();
809   }
810   else {
811     return -1;
812   }
813 }
814
815 void BKE_sound_free_waveform(bSound *sound)
816 {
817   if ((sound->tags & SOUND_TAGS_WAVEFORM_NO_RELOAD) == 0) {
818     SoundWaveform *waveform = sound->waveform;
819     if (waveform) {
820       if (waveform->data) {
821         MEM_freeN(waveform->data);
822       }
823       MEM_freeN(waveform);
824     }
825
826     sound->waveform = NULL;
827   }
828   /* This tag is only valid once. */
829   sound->tags &= ~SOUND_TAGS_WAVEFORM_NO_RELOAD;
830 }
831
832 void BKE_sound_read_waveform(bSound *sound, short *stop)
833 {
834   AUD_SoundInfo info = AUD_getInfo(sound->playback_handle);
835   SoundWaveform *waveform = MEM_mallocN(sizeof(SoundWaveform), "SoundWaveform");
836
837   if (info.length > 0) {
838     int length = info.length * SOUND_WAVE_SAMPLES_PER_SECOND;
839
840     waveform->data = MEM_mallocN(length * sizeof(float) * 3, "SoundWaveform.samples");
841     waveform->length = AUD_readSound(
842         sound->playback_handle, waveform->data, length, SOUND_WAVE_SAMPLES_PER_SECOND, stop);
843   }
844   else {
845     /* Create an empty waveform here if the sound couldn't be
846      * read. This indicates that reading the waveform is "done",
847      * whereas just setting sound->waveform to NULL causes other
848      * code to think the waveform still needs to be created. */
849     waveform->data = NULL;
850     waveform->length = 0;
851   }
852
853   if (*stop) {
854     if (waveform->data) {
855       MEM_freeN(waveform->data);
856     }
857     MEM_freeN(waveform);
858     BLI_spin_lock(sound->spinlock);
859     sound->tags &= ~SOUND_TAGS_WAVEFORM_LOADING;
860     BLI_spin_unlock(sound->spinlock);
861     return;
862   }
863
864   BKE_sound_free_waveform(sound);
865
866   BLI_spin_lock(sound->spinlock);
867   sound->waveform = waveform;
868   sound->tags &= ~SOUND_TAGS_WAVEFORM_LOADING;
869   BLI_spin_unlock(sound->spinlock);
870 }
871
872 static void sound_update_base(Scene *scene, Base *base, void *new_set)
873 {
874   Object *ob = base->object;
875   NlaTrack *track;
876   NlaStrip *strip;
877   Speaker *speaker;
878   float quat[4];
879
880   if ((ob->id.tag & LIB_TAG_DOIT) == 0) {
881     return;
882   }
883
884   ob->id.tag &= ~LIB_TAG_DOIT;
885
886   if ((ob->type != OB_SPEAKER) || !ob->adt) {
887     return;
888   }
889
890   for (track = ob->adt->nla_tracks.first; track; track = track->next) {
891     for (strip = track->strips.first; strip; strip = strip->next) {
892       if (strip->type != NLASTRIP_TYPE_SOUND) {
893         continue;
894       }
895       speaker = (Speaker *)ob->data;
896
897       if (AUD_removeSet(scene->speaker_handles, strip->speaker_handle)) {
898         if (speaker->sound) {
899           AUD_SequenceEntry_move(strip->speaker_handle, (double)strip->start / FPS, FLT_MAX, 0);
900         }
901         else {
902           AUD_Sequence_remove(scene->sound_scene, strip->speaker_handle);
903           strip->speaker_handle = NULL;
904         }
905       }
906       else {
907         if (speaker->sound) {
908           strip->speaker_handle = AUD_Sequence_add(scene->sound_scene,
909                                                    speaker->sound->playback_handle,
910                                                    (double)strip->start / FPS,
911                                                    FLT_MAX,
912                                                    0);
913           AUD_SequenceEntry_setRelative(strip->speaker_handle, 0);
914         }
915       }
916
917       if (strip->speaker_handle) {
918         const bool mute = ((strip->flag & NLASTRIP_FLAG_MUTED) || (speaker->flag & SPK_MUTED));
919         AUD_addSet(new_set, strip->speaker_handle);
920         AUD_SequenceEntry_setVolumeMaximum(strip->speaker_handle, speaker->volume_max);
921         AUD_SequenceEntry_setVolumeMinimum(strip->speaker_handle, speaker->volume_min);
922         AUD_SequenceEntry_setDistanceMaximum(strip->speaker_handle, speaker->distance_max);
923         AUD_SequenceEntry_setDistanceReference(strip->speaker_handle, speaker->distance_reference);
924         AUD_SequenceEntry_setAttenuation(strip->speaker_handle, speaker->attenuation);
925         AUD_SequenceEntry_setConeAngleOuter(strip->speaker_handle, speaker->cone_angle_outer);
926         AUD_SequenceEntry_setConeAngleInner(strip->speaker_handle, speaker->cone_angle_inner);
927         AUD_SequenceEntry_setConeVolumeOuter(strip->speaker_handle, speaker->cone_volume_outer);
928
929         mat4_to_quat(quat, ob->obmat);
930         AUD_SequenceEntry_setAnimationData(
931             strip->speaker_handle, AUD_AP_LOCATION, CFRA, ob->obmat[3], 1);
932         AUD_SequenceEntry_setAnimationData(
933             strip->speaker_handle, AUD_AP_ORIENTATION, CFRA, quat, 1);
934         AUD_SequenceEntry_setAnimationData(
935             strip->speaker_handle, AUD_AP_VOLUME, CFRA, &speaker->volume, 1);
936         AUD_SequenceEntry_setAnimationData(
937             strip->speaker_handle, AUD_AP_PITCH, CFRA, &speaker->pitch, 1);
938         AUD_SequenceEntry_setSound(strip->speaker_handle, speaker->sound->playback_handle);
939         AUD_SequenceEntry_setMuted(strip->speaker_handle, mute);
940       }
941     }
942   }
943 }
944
945 void BKE_sound_update_scene(Main *bmain, Scene *scene)
946 {
947   Base *base;
948   Scene *sce_it;
949
950   void *new_set = AUD_createSet();
951   void *handle;
952   float quat[4];
953
954   /* cheap test to skip looping over all objects (no speakers is a common case) */
955   if (!BLI_listbase_is_empty(&bmain->speakers)) {
956     BKE_main_id_tag_listbase(&bmain->objects, LIB_TAG_DOIT, true);
957
958     for (ViewLayer *view_layer = scene->view_layers.first; view_layer;
959          view_layer = view_layer->next) {
960       for (base = view_layer->object_bases.first; base; base = base->next) {
961         sound_update_base(scene, base, new_set);
962       }
963     }
964
965     for (SETLOOPER_SET_ONLY(scene, sce_it, base)) {
966       sound_update_base(scene, base, new_set);
967     }
968   }
969
970   while ((handle = AUD_getSet(scene->speaker_handles))) {
971     AUD_Sequence_remove(scene->sound_scene, handle);
972   }
973
974   if (scene->camera) {
975     mat4_to_quat(quat, scene->camera->obmat);
976     AUD_Sequence_setAnimationData(
977         scene->sound_scene, AUD_AP_LOCATION, CFRA, scene->camera->obmat[3], 1);
978     AUD_Sequence_setAnimationData(scene->sound_scene, AUD_AP_ORIENTATION, CFRA, quat, 1);
979   }
980
981   AUD_destroySet(scene->speaker_handles);
982   scene->speaker_handles = new_set;
983 }
984
985 void *BKE_sound_get_factory(void *sound)
986 {
987   return ((bSound *)sound)->playback_handle;
988 }
989
990 /* stupid wrapper because AUD_C-API.h includes Python.h which makesrna doesn't like */
991 float BKE_sound_get_length(bSound *sound)
992 {
993   AUD_SoundInfo info = AUD_getInfo(sound->playback_handle);
994
995   return info.length;
996 }
997
998 char **BKE_sound_get_device_names(void)
999 {
1000   if (audio_device_names == NULL) {
1001     audio_device_names = AUD_getDeviceNames();
1002   }
1003
1004   return audio_device_names;
1005 }
1006
1007 #else /* WITH_AUDASPACE */
1008
1009 #  include "BLI_utildefines.h"
1010
1011 void BKE_sound_force_device(const char *UNUSED(device))
1012 {
1013 }
1014 void BKE_sound_init_once(void)
1015 {
1016 }
1017 void BKE_sound_init(struct Main *UNUSED(bmain))
1018 {
1019 }
1020 void BKE_sound_exit(void)
1021 {
1022 }
1023 void BKE_sound_exit_once(void)
1024 {
1025 }
1026 void BKE_sound_cache(struct bSound *UNUSED(sound))
1027 {
1028 }
1029 void BKE_sound_delete_cache(struct bSound *UNUSED(sound))
1030 {
1031 }
1032 void BKE_sound_load(struct Main *UNUSED(bmain), struct bSound *UNUSED(sound))
1033 {
1034 }
1035 void BKE_sound_create_scene(struct Scene *UNUSED(scene))
1036 {
1037 }
1038 void BKE_sound_destroy_scene(struct Scene *UNUSED(scene))
1039 {
1040 }
1041 void BKE_sound_reset_scene_specs(struct Scene *UNUSED(scene))
1042 {
1043 }
1044 void BKE_sound_mute_scene(struct Scene *UNUSED(scene), int UNUSED(muted))
1045 {
1046 }
1047 void *BKE_sound_scene_add_scene_sound(struct Scene *UNUSED(scene),
1048                                       struct Sequence *UNUSED(sequence),
1049                                       int UNUSED(startframe),
1050                                       int UNUSED(endframe),
1051                                       int UNUSED(frameskip))
1052 {
1053   return NULL;
1054 }
1055 void *BKE_sound_scene_add_scene_sound_defaults(struct Scene *UNUSED(scene),
1056                                                struct Sequence *UNUSED(sequence))
1057 {
1058   return NULL;
1059 }
1060 void *BKE_sound_add_scene_sound(struct Scene *UNUSED(scene),
1061                                 struct Sequence *UNUSED(sequence),
1062                                 int UNUSED(startframe),
1063                                 int UNUSED(endframe),
1064                                 int UNUSED(frameskip))
1065 {
1066   return NULL;
1067 }
1068 void *BKE_sound_add_scene_sound_defaults(struct Scene *UNUSED(scene),
1069                                          struct Sequence *UNUSED(sequence))
1070 {
1071   return NULL;
1072 }
1073 void BKE_sound_remove_scene_sound(struct Scene *UNUSED(scene), void *UNUSED(handle))
1074 {
1075 }
1076 void BKE_sound_mute_scene_sound(void *UNUSED(handle), char UNUSED(mute))
1077 {
1078 }
1079 void BKE_sound_move_scene_sound(struct Scene *UNUSED(scene),
1080                                 void *UNUSED(handle),
1081                                 int UNUSED(startframe),
1082                                 int UNUSED(endframe),
1083                                 int UNUSED(frameskip))
1084 {
1085 }
1086 void BKE_sound_move_scene_sound_defaults(struct Scene *UNUSED(scene),
1087                                          struct Sequence *UNUSED(sequence))
1088 {
1089 }
1090 void BKE_sound_play_scene(struct Scene *UNUSED(scene))
1091 {
1092 }
1093 void BKE_sound_stop_scene(struct Scene *UNUSED(scene))
1094 {
1095 }
1096 void BKE_sound_seek_scene(struct Main *UNUSED(bmain), struct Scene *UNUSED(scene))
1097 {
1098 }
1099 float BKE_sound_sync_scene(struct Scene *UNUSED(scene))
1100 {
1101   return NAN_FLT;
1102 }
1103 int BKE_sound_scene_playing(struct Scene *UNUSED(scene))
1104 {
1105   return -1;
1106 }
1107 void BKE_sound_read_waveform(struct bSound *sound, short *stop)
1108 {
1109   UNUSED_VARS(sound, stop);
1110 }
1111 void BKE_sound_init_main(struct Main *UNUSED(bmain))
1112 {
1113 }
1114 void BKE_sound_set_cfra(int UNUSED(cfra))
1115 {
1116 }
1117 void BKE_sound_update_sequencer(struct Main *UNUSED(main), struct bSound *UNUSED(sound))
1118 {
1119 }
1120 void BKE_sound_update_scene(struct Main *UNUSED(bmain), struct Scene *UNUSED(scene))
1121 {
1122 }
1123 void BKE_sound_update_scene_sound(void *UNUSED(handle), struct bSound *UNUSED(sound))
1124 {
1125 }
1126 void BKE_sound_update_scene_listener(struct Scene *UNUSED(scene))
1127 {
1128 }
1129 void BKE_sound_update_fps(struct Scene *UNUSED(scene))
1130 {
1131 }
1132 void BKE_sound_set_scene_sound_volume(void *UNUSED(handle),
1133                                       float UNUSED(volume),
1134                                       char UNUSED(animated))
1135 {
1136 }
1137 void BKE_sound_set_scene_sound_pan(void *UNUSED(handle), float UNUSED(pan), char UNUSED(animated))
1138 {
1139 }
1140 void BKE_sound_set_scene_volume(struct Scene *UNUSED(scene), float UNUSED(volume))
1141 {
1142 }
1143 void BKE_sound_set_scene_sound_pitch(void *UNUSED(handle),
1144                                      float UNUSED(pitch),
1145                                      char UNUSED(animated))
1146 {
1147 }
1148 float BKE_sound_get_length(struct bSound *UNUSED(sound))
1149 {
1150   return 0;
1151 }
1152 char **BKE_sound_get_device_names(void)
1153 {
1154   static char *names[1] = {NULL};
1155   return names;
1156 }
1157
1158 #endif /* WITH_AUDASPACE */