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