Fix T66948: Outliner - collections/objects with wrong active state
[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_iterator.h"
31 #include "BLI_math.h"
32 #include "BLI_threads.h"
33
34 #include "DNA_anim_types.h"
35 #include "DNA_object_types.h"
36 #include "DNA_scene_types.h"
37 #include "DNA_sequence_types.h"
38 #include "DNA_packedFile_types.h"
39 #include "DNA_screen_types.h"
40 #include "DNA_sound_types.h"
41 #include "DNA_speaker_types.h"
42 #include "DNA_windowmanager_types.h"
43
44 #ifdef WITH_AUDASPACE
45 #  include <AUD_Sound.h>
46 #  include <AUD_Sequence.h>
47 #  include <AUD_Handle.h>
48 #  include <AUD_Special.h>
49 #  include "../../../intern/audaspace/intern/AUD_Set.h"
50 #endif
51
52 #include "BKE_global.h"
53 #include "BKE_main.h"
54 #include "BKE_sound.h"
55 #include "BKE_library.h"
56 #include "BKE_packedFile.h"
57 #include "BKE_sequencer.h"
58 #include "BKE_scene.h"
59
60 #include "DEG_depsgraph.h"
61 #include "DEG_depsgraph_query.h"
62
63 #ifdef WITH_AUDASPACE
64 /* evil globals ;-) */
65 static int sound_cfra;
66 static char **audio_device_names = NULL;
67 #endif
68
69 BLI_INLINE void sound_verify_evaluated_id(ID *id)
70 {
71   UNUSED_VARS_NDEBUG(id);
72   /* This is a bit tricky and not quite reliable, but good enough check.
73    *
74    * We don't want audio system handles to be allocated on an original data-blocks, and only want
75    * them to be allocated on a data-blocks which are result of dependency graph evaluation.
76    *
77    * Data-blocks which are covered by a copy-on-write system of dependency graph will have
78    * LIB_TAG_COPIED_ON_WRITE tag set on them. But if some of data-blocks during its evaluation
79    * decides to re-allocate it's nested one (for example, object evaluation could re-allocate mesh
80    * when evaluating modifier stack). Such data-blocks will have
81    * LIB_TAG_COPIED_ON_WRITE_EVAL_RESULT tag set on them.
82    *
83    * Additionally, we also allow data-blocks outside of main database. Those can not be "original"
84    * and could be used as a temporary evaluated result during operations like baking.
85    *
86    * NOTE: We consider ID evaluated if ANY of those flags is set. We do NOT require ALL of them.
87    */
88   BLI_assert(id->tag &
89              (LIB_TAG_COPIED_ON_WRITE | LIB_TAG_COPIED_ON_WRITE_EVAL_RESULT | LIB_TAG_NO_MAIN));
90 }
91
92 bSound *BKE_sound_new_file(Main *bmain, const char *filepath)
93 {
94   bSound *sound;
95   const char *path;
96   char str[FILE_MAX];
97
98   BLI_strncpy(str, filepath, sizeof(str));
99
100   path = BKE_main_blendfile_path(bmain);
101
102   BLI_path_abs(str, path);
103
104   sound = BKE_libblock_alloc(bmain, ID_SO, BLI_path_basename(filepath), 0);
105   BLI_strncpy(sound->name, filepath, FILE_MAX);
106   /* sound->type = SOUND_TYPE_FILE; */ /* XXX unused currently */
107
108   sound->spinlock = MEM_mallocN(sizeof(SpinLock), "sound_spinlock");
109   BLI_spin_init(sound->spinlock);
110
111   BKE_sound_reset_runtime(sound);
112
113   return sound;
114 }
115
116 bSound *BKE_sound_new_file_exists_ex(Main *bmain, const char *filepath, bool *r_exists)
117 {
118   bSound *sound;
119   char str[FILE_MAX], strtest[FILE_MAX];
120
121   BLI_strncpy(str, filepath, sizeof(str));
122   BLI_path_abs(str, BKE_main_blendfile_path(bmain));
123
124   /* first search an identical filepath */
125   for (sound = bmain->sounds.first; sound; sound = sound->id.next) {
126     BLI_strncpy(strtest, sound->name, sizeof(sound->name));
127     BLI_path_abs(strtest, ID_BLEND_PATH(bmain, &sound->id));
128
129     if (BLI_path_cmp(strtest, str) == 0) {
130       id_us_plus(&sound->id); /* officially should not, it doesn't link here! */
131       if (r_exists) {
132         *r_exists = true;
133       }
134       return sound;
135     }
136   }
137
138   if (r_exists) {
139     *r_exists = false;
140   }
141   return BKE_sound_new_file(bmain, filepath);
142 }
143
144 bSound *BKE_sound_new_file_exists(Main *bmain, const char *filepath)
145 {
146   return BKE_sound_new_file_exists_ex(bmain, filepath, NULL);
147 }
148
149 static void sound_free_audio(bSound *sound)
150 {
151 #ifdef WITH_AUDASPACE
152   if (sound->handle) {
153     AUD_Sound_free(sound->handle);
154     sound->handle = NULL;
155     sound->playback_handle = NULL;
156   }
157
158   if (sound->cache) {
159     AUD_Sound_free(sound->cache);
160     sound->cache = NULL;
161   }
162 #else
163   UNUSED_VARS(sound);
164 #endif /* WITH_AUDASPACE */
165 }
166
167 /** Free (or release) any data used by this sound (does not free the sound itself). */
168 void BKE_sound_free(bSound *sound)
169 {
170   /* No animdata here. */
171
172   if (sound->packedfile) {
173     BKE_packedfile_free(sound->packedfile);
174     sound->packedfile = NULL;
175   }
176
177   sound_free_audio(sound);
178   BKE_sound_free_waveform(sound);
179
180   if (sound->spinlock) {
181     BLI_spin_end(sound->spinlock);
182     MEM_freeN(sound->spinlock);
183     sound->spinlock = NULL;
184   }
185 }
186
187 /**
188  * Only copy internal data of Sound ID from source
189  * to already allocated/initialized destination.
190  * You probably never want to use that directly,
191  * use #BKE_id_copy or #BKE_id_copy_ex for typical needs.
192  *
193  * WARNING! This function will not handle ID user count!
194  *
195  * \param flag: Copying options (see BKE_library.h's LIB_ID_COPY_... flags for more).
196  */
197 void BKE_sound_copy_data(Main *UNUSED(bmain),
198                          bSound *sound_dst,
199                          const bSound *UNUSED(sound_src),
200                          const int UNUSED(flag))
201 {
202   sound_dst->handle = NULL;
203   sound_dst->cache = NULL;
204   sound_dst->waveform = NULL;
205   sound_dst->playback_handle = NULL;
206   sound_dst->spinlock = MEM_mallocN(sizeof(SpinLock), "sound_spinlock");
207   BLI_spin_init(sound_dst->spinlock);
208
209   /* Just to be sure, should not have any value actually after reading time. */
210   sound_dst->ipo = NULL;
211   sound_dst->newpackedfile = NULL;
212
213   if (sound_dst->packedfile) {
214     sound_dst->packedfile = BKE_packedfile_duplicate(sound_dst->packedfile);
215   }
216
217   BKE_sound_reset_runtime(sound_dst);
218 }
219
220 void BKE_sound_make_local(Main *bmain, bSound *sound, const bool lib_local)
221 {
222   BKE_id_make_local_generic(bmain, &sound->id, true, lib_local);
223 }
224
225 #ifdef WITH_AUDASPACE
226
227 static const char *force_device = NULL;
228
229 #  ifdef WITH_JACK
230 static SoundJackSyncCallback sound_jack_sync_callback = NULL;
231
232 static void sound_sync_callback(void *data, int mode, float time)
233 {
234   if (sound_jack_sync_callback == NULL) {
235     return;
236   }
237   Main *bmain = (Main *)data;
238   sound_jack_sync_callback(bmain, mode, time);
239 }
240 #  endif
241
242 void BKE_sound_force_device(const char *device)
243 {
244   force_device = device;
245 }
246
247 void BKE_sound_init_once(void)
248 {
249   AUD_initOnce();
250   atexit(BKE_sound_exit_once);
251 }
252
253 static AUD_Device *sound_device = NULL;
254
255 void *BKE_sound_get_device(void)
256 {
257   return sound_device;
258 }
259
260 void BKE_sound_init(Main *bmain)
261 {
262   /* Make sure no instance of the sound system is running, otherwise we get leaks. */
263   BKE_sound_exit();
264
265   AUD_DeviceSpecs specs;
266   int device, buffersize;
267   const char *device_name;
268
269   device = U.audiodevice;
270   buffersize = U.mixbufsize;
271   specs.channels = U.audiochannels;
272   specs.format = U.audioformat;
273   specs.rate = U.audiorate;
274
275   if (force_device == NULL) {
276     int i;
277     char **names = BKE_sound_get_device_names();
278     device_name = names[0];
279
280     /* make sure device is within the bounds of the array */
281     for (i = 0; names[i]; i++) {
282       if (i == device) {
283         device_name = names[i];
284       }
285     }
286   }
287   else {
288     device_name = force_device;
289   }
290
291   if (buffersize < 128) {
292     buffersize = 1024;
293   }
294
295   if (specs.rate < AUD_RATE_8000) {
296     specs.rate = AUD_RATE_48000;
297   }
298
299   if (specs.format <= AUD_FORMAT_INVALID) {
300     specs.format = AUD_FORMAT_S16;
301   }
302
303   if (specs.channels <= AUD_CHANNELS_INVALID) {
304     specs.channels = AUD_CHANNELS_STEREO;
305   }
306
307   if (!(sound_device = AUD_init(device_name, specs, buffersize, "Blender"))) {
308     sound_device = AUD_init("Null", specs, buffersize, "Blender");
309   }
310
311   BKE_sound_init_main(bmain);
312 }
313
314 void BKE_sound_init_main(Main *bmain)
315 {
316 #  ifdef WITH_JACK
317   if (sound_device) {
318     AUD_setSynchronizerCallback(sound_sync_callback, bmain);
319   }
320 #  else
321   UNUSED_VARS(bmain);
322 #  endif
323 }
324
325 void BKE_sound_exit(void)
326 {
327   AUD_exit(sound_device);
328   sound_device = NULL;
329 }
330
331 void BKE_sound_exit_once(void)
332 {
333   AUD_exit(sound_device);
334   sound_device = NULL;
335   AUD_exitOnce();
336
337   if (audio_device_names != NULL) {
338     int i;
339     for (i = 0; audio_device_names[i]; i++) {
340       free(audio_device_names[i]);
341     }
342     free(audio_device_names);
343     audio_device_names = NULL;
344   }
345 }
346
347 /* XXX unused currently */
348 #  if 0
349 bSound *BKE_sound_new_buffer(Main *bmain, bSound *source)
350 {
351   bSound *sound = NULL;
352
353   char name[MAX_ID_NAME + 5];
354   strcpy(name, "buf_");
355   strcpy(name + 4, source->id.name);
356
357   sound = BKE_libblock_alloc(bmain, ID_SO, name);
358
359   sound->child_sound = source;
360   sound->type = SOUND_TYPE_BUFFER;
361
362   sound_load(bmain, sound);
363
364   return sound;
365 }
366
367 bSound *BKE_sound_new_limiter(Main *bmain, bSound *source, float start, float end)
368 {
369   bSound *sound = NULL;
370
371   char name[MAX_ID_NAME + 5];
372   strcpy(name, "lim_");
373   strcpy(name + 4, source->id.name);
374
375   sound = BKE_libblock_alloc(bmain, ID_SO, name);
376
377   sound->child_sound = source;
378   sound->start = start;
379   sound->end = end;
380   sound->type = SOUND_TYPE_LIMITER;
381
382   sound_load(bmain, sound);
383
384   return sound;
385 }
386 #  endif
387
388 void BKE_sound_cache(bSound *sound)
389 {
390   sound_verify_evaluated_id(&sound->id);
391
392   if (sound->cache) {
393     AUD_Sound_free(sound->cache);
394   }
395
396   sound->cache = AUD_Sound_cache(sound->handle);
397   if (sound->cache) {
398     sound->playback_handle = sound->cache;
399   }
400   else {
401     sound->playback_handle = sound->handle;
402   }
403 }
404
405 void BKE_sound_delete_cache(bSound *sound)
406 {
407   if (sound->cache) {
408     AUD_Sound_free(sound->cache);
409     sound->cache = NULL;
410     sound->playback_handle = sound->handle;
411   }
412 }
413
414 static void sound_load_audio(Main *bmain, bSound *sound)
415 {
416
417   if (sound->cache) {
418     AUD_Sound_free(sound->cache);
419     sound->cache = NULL;
420   }
421
422   if (sound->handle) {
423     AUD_Sound_free(sound->handle);
424     sound->handle = NULL;
425     sound->playback_handle = NULL;
426   }
427
428   BKE_sound_free_waveform(sound);
429
430 /* XXX unused currently */
431 #  if 0
432     switch (sound->type) {
433       case SOUND_TYPE_FILE:
434 #  endif
435   {
436     char fullpath[FILE_MAX];
437
438     /* load sound */
439     PackedFile *pf = sound->packedfile;
440
441     /* don't modify soundact->sound->name, only change a copy */
442     BLI_strncpy(fullpath, sound->name, sizeof(fullpath));
443     BLI_path_abs(fullpath, ID_BLEND_PATH(bmain, &sound->id));
444
445     /* but we need a packed file then */
446     if (pf) {
447       sound->handle = AUD_Sound_bufferFile((unsigned char *)pf->data, pf->size);
448     }
449     else {
450       /* or else load it from disk */
451       sound->handle = AUD_Sound_file(fullpath);
452     }
453   }
454 /* XXX unused currently */
455 #  if 0
456       break;
457     }
458     case SOUND_TYPE_BUFFER:
459       if (sound->child_sound && sound->child_sound->handle) {
460         sound->handle = AUD_bufferSound(sound->child_sound->handle);
461       }
462       break;
463     case SOUND_TYPE_LIMITER:
464       if (sound->child_sound && sound->child_sound->handle) {
465         sound->handle = AUD_limitSound(sound->child_sound, sound->start, sound->end);
466       }
467       break;
468   }
469 #  endif
470   if (sound->flags & SOUND_FLAGS_MONO) {
471     void *handle = AUD_Sound_rechannel(sound->handle, AUD_CHANNELS_MONO);
472     AUD_Sound_free(sound->handle);
473     sound->handle = handle;
474   }
475
476   if (sound->flags & SOUND_FLAGS_CACHING) {
477     sound->cache = AUD_Sound_cache(sound->handle);
478   }
479
480   if (sound->cache) {
481     sound->playback_handle = sound->cache;
482   }
483   else {
484     sound->playback_handle = sound->handle;
485   }
486 }
487
488 void BKE_sound_load(Main *bmain, bSound *sound)
489 {
490   sound_verify_evaluated_id(&sound->id);
491   sound_load_audio(bmain, sound);
492 }
493
494 AUD_Device *BKE_sound_mixdown(Scene *scene, AUD_DeviceSpecs specs, int start, float volume)
495 {
496   sound_verify_evaluated_id(&scene->id);
497   return AUD_openMixdownDevice(specs, scene->sound_scene, volume, start / FPS);
498 }
499
500 void BKE_sound_create_scene(Scene *scene)
501 {
502   sound_verify_evaluated_id(&scene->id);
503
504   /* should be done in version patch, but this gets called before */
505   if (scene->r.frs_sec_base == 0) {
506     scene->r.frs_sec_base = 1;
507   }
508
509   scene->sound_scene = AUD_Sequence_create(FPS, scene->audio.flag & AUDIO_MUTE);
510   AUD_Sequence_setSpeedOfSound(scene->sound_scene, scene->audio.speed_of_sound);
511   AUD_Sequence_setDopplerFactor(scene->sound_scene, scene->audio.doppler_factor);
512   AUD_Sequence_setDistanceModel(scene->sound_scene, scene->audio.distance_model);
513   scene->playback_handle = NULL;
514   scene->sound_scrub_handle = NULL;
515   scene->speaker_handles = NULL;
516 }
517
518 void BKE_sound_destroy_scene(Scene *scene)
519 {
520   if (scene->playback_handle) {
521     AUD_Handle_stop(scene->playback_handle);
522   }
523   if (scene->sound_scrub_handle) {
524     AUD_Handle_stop(scene->sound_scrub_handle);
525   }
526   if (scene->speaker_handles) {
527     void *handle;
528
529     while ((handle = AUD_getSet(scene->speaker_handles))) {
530       AUD_Sequence_remove(scene->sound_scene, handle);
531     }
532
533     AUD_destroySet(scene->speaker_handles);
534   }
535   if (scene->sound_scene) {
536     AUD_Sequence_free(scene->sound_scene);
537   }
538 }
539
540 void BKE_sound_reset_scene_specs(Scene *scene)
541 {
542   sound_verify_evaluated_id(&scene->id);
543
544   if (scene->sound_scene) {
545     AUD_Specs specs;
546
547     specs.channels = AUD_Device_getChannels(sound_device);
548     specs.rate = AUD_Device_getRate(sound_device);
549
550     AUD_Sequence_setSpecs(scene->sound_scene, specs);
551   }
552 }
553
554 void BKE_sound_mute_scene(Scene *scene, int muted)
555 {
556   sound_verify_evaluated_id(&scene->id);
557   if (scene->sound_scene) {
558     AUD_Sequence_setMuted(scene->sound_scene, muted);
559   }
560 }
561
562 void BKE_sound_update_fps(Main *bmain, Scene *scene)
563 {
564   sound_verify_evaluated_id(&scene->id);
565
566   if (scene->sound_scene) {
567     AUD_Sequence_setFPS(scene->sound_scene, FPS);
568   }
569
570   BKE_sequencer_refresh_sound_length(bmain, scene);
571 }
572
573 void BKE_sound_update_scene_listener(Scene *scene)
574 {
575   sound_verify_evaluated_id(&scene->id);
576
577   AUD_Sequence_setSpeedOfSound(scene->sound_scene, scene->audio.speed_of_sound);
578   AUD_Sequence_setDopplerFactor(scene->sound_scene, scene->audio.doppler_factor);
579   AUD_Sequence_setDistanceModel(scene->sound_scene, scene->audio.distance_model);
580 }
581
582 void *BKE_sound_scene_add_scene_sound(
583     Scene *scene, Sequence *sequence, int startframe, int endframe, int frameskip)
584 {
585   sound_verify_evaluated_id(&scene->id);
586   if (sequence->scene && scene != sequence->scene) {
587     const double fps = FPS;
588     return AUD_Sequence_add(scene->sound_scene,
589                             sequence->scene->sound_scene,
590                             startframe / fps,
591                             endframe / fps,
592                             frameskip / fps);
593   }
594   return NULL;
595 }
596
597 void *BKE_sound_scene_add_scene_sound_defaults(Scene *scene, Sequence *sequence)
598 {
599   return BKE_sound_scene_add_scene_sound(scene,
600                                          sequence,
601                                          sequence->startdisp,
602                                          sequence->enddisp,
603                                          sequence->startofs + sequence->anim_startofs);
604 }
605
606 void *BKE_sound_add_scene_sound(
607     Scene *scene, Sequence *sequence, int startframe, int endframe, int frameskip)
608 {
609   sound_verify_evaluated_id(&scene->id);
610   /* Happens when sequence's sound data-block was removed. */
611   if (sequence->sound == NULL) {
612     return NULL;
613   }
614   sound_verify_evaluated_id(&sequence->sound->id);
615   const double fps = FPS;
616   void *handle = AUD_Sequence_add(scene->sound_scene,
617                                   sequence->sound->playback_handle,
618                                   startframe / fps,
619                                   endframe / fps,
620                                   frameskip / fps);
621   AUD_SequenceEntry_setMuted(handle, (sequence->flag & SEQ_MUTE) != 0);
622   AUD_SequenceEntry_setAnimationData(handle, AUD_AP_VOLUME, CFRA, &sequence->volume, 0);
623   AUD_SequenceEntry_setAnimationData(handle, AUD_AP_PITCH, CFRA, &sequence->pitch, 0);
624   AUD_SequenceEntry_setAnimationData(handle, AUD_AP_PANNING, CFRA, &sequence->pan, 0);
625   return handle;
626 }
627
628 void *BKE_sound_add_scene_sound_defaults(Scene *scene, Sequence *sequence)
629 {
630   return BKE_sound_add_scene_sound(scene,
631                                    sequence,
632                                    sequence->startdisp,
633                                    sequence->enddisp,
634                                    sequence->startofs + sequence->anim_startofs);
635 }
636
637 void BKE_sound_remove_scene_sound(Scene *scene, void *handle)
638 {
639   AUD_Sequence_remove(scene->sound_scene, handle);
640 }
641
642 void BKE_sound_mute_scene_sound(void *handle, char mute)
643 {
644   AUD_SequenceEntry_setMuted(handle, mute);
645 }
646
647 void BKE_sound_move_scene_sound(
648     Scene *scene, void *handle, int startframe, int endframe, int frameskip)
649 {
650   sound_verify_evaluated_id(&scene->id);
651   const double fps = FPS;
652   AUD_SequenceEntry_move(handle, startframe / fps, endframe / fps, frameskip / fps);
653 }
654
655 void BKE_sound_move_scene_sound_defaults(Scene *scene, Sequence *sequence)
656 {
657   sound_verify_evaluated_id(&scene->id);
658   if (sequence->scene_sound) {
659     BKE_sound_move_scene_sound(scene,
660                                sequence->scene_sound,
661                                sequence->startdisp,
662                                sequence->enddisp,
663                                sequence->startofs + sequence->anim_startofs);
664   }
665 }
666
667 void BKE_sound_update_scene_sound(void *handle, bSound *sound)
668 {
669   AUD_SequenceEntry_setSound(handle, sound->playback_handle);
670 }
671
672 void BKE_sound_set_cfra(int cfra)
673 {
674   sound_cfra = cfra;
675 }
676
677 void BKE_sound_set_scene_volume(Scene *scene, float volume)
678 {
679   sound_verify_evaluated_id(&scene->id);
680   AUD_Sequence_setAnimationData(scene->sound_scene,
681                                 AUD_AP_VOLUME,
682                                 CFRA,
683                                 &volume,
684                                 (scene->audio.flag & AUDIO_VOLUME_ANIMATED) != 0);
685 }
686
687 void BKE_sound_set_scene_sound_volume(void *handle, float volume, char animated)
688 {
689   AUD_SequenceEntry_setAnimationData(handle, AUD_AP_VOLUME, sound_cfra, &volume, animated);
690 }
691
692 void BKE_sound_set_scene_sound_pitch(void *handle, float pitch, char animated)
693 {
694   AUD_SequenceEntry_setAnimationData(handle, AUD_AP_PITCH, sound_cfra, &pitch, animated);
695 }
696
697 void BKE_sound_set_scene_sound_pan(void *handle, float pan, char animated)
698 {
699   AUD_SequenceEntry_setAnimationData(handle, AUD_AP_PANNING, sound_cfra, &pan, animated);
700 }
701
702 void BKE_sound_update_sequencer(Main *main, bSound *sound)
703 {
704   BLI_assert(!"is not supposed to be used, is weird function.");
705
706   Scene *scene;
707
708   for (scene = main->scenes.first; scene; scene = scene->id.next) {
709     BKE_sequencer_update_sound(scene, sound);
710   }
711 }
712
713 static void sound_start_play_scene(Scene *scene)
714 {
715   sound_verify_evaluated_id(&scene->id);
716
717   if (scene->playback_handle) {
718     AUD_Handle_stop(scene->playback_handle);
719   }
720
721   BKE_sound_reset_scene_specs(scene);
722
723   if ((scene->playback_handle = AUD_Device_play(sound_device, scene->sound_scene, 1))) {
724     AUD_Handle_setLoopCount(scene->playback_handle, -1);
725   }
726 }
727
728 void BKE_sound_play_scene(Scene *scene)
729 {
730   sound_verify_evaluated_id(&scene->id);
731
732   AUD_Status status;
733   const float cur_time = (float)((double)CFRA / FPS);
734
735   AUD_Device_lock(sound_device);
736
737   status = scene->playback_handle ? AUD_Handle_getStatus(scene->playback_handle) :
738                                     AUD_STATUS_INVALID;
739
740   if (status == AUD_STATUS_INVALID) {
741     sound_start_play_scene(scene);
742
743     if (!scene->playback_handle) {
744       AUD_Device_unlock(sound_device);
745       return;
746     }
747   }
748
749   if (status != AUD_STATUS_PLAYING) {
750     AUD_Handle_setPosition(scene->playback_handle, cur_time);
751     AUD_Handle_resume(scene->playback_handle);
752   }
753
754   if (scene->audio.flag & AUDIO_SYNC) {
755     AUD_playSynchronizer();
756   }
757
758   AUD_Device_unlock(sound_device);
759 }
760
761 void BKE_sound_stop_scene(Scene *scene)
762 {
763   if (scene->playback_handle) {
764     AUD_Handle_pause(scene->playback_handle);
765
766     if (scene->audio.flag & AUDIO_SYNC) {
767       AUD_stopSynchronizer();
768     }
769   }
770 }
771
772 void BKE_sound_seek_scene(Main *bmain, Scene *scene)
773 {
774   sound_verify_evaluated_id(&scene->id);
775
776   AUD_Status status;
777   bScreen *screen;
778   int animation_playing;
779
780   const float one_frame = (float)(1.0 / FPS);
781   const float cur_time = (float)((double)CFRA / FPS);
782
783   AUD_Device_lock(sound_device);
784
785   status = scene->playback_handle ? AUD_Handle_getStatus(scene->playback_handle) :
786                                     AUD_STATUS_INVALID;
787
788   if (status == AUD_STATUS_INVALID) {
789     sound_start_play_scene(scene);
790
791     if (!scene->playback_handle) {
792       AUD_Device_unlock(sound_device);
793       return;
794     }
795
796     AUD_Handle_pause(scene->playback_handle);
797   }
798
799   animation_playing = 0;
800   for (screen = bmain->screens.first; screen; screen = screen->id.next) {
801     if (screen->animtimer) {
802       animation_playing = 1;
803       break;
804     }
805   }
806
807   if (scene->audio.flag & AUDIO_SCRUB && !animation_playing) {
808     AUD_Handle_setPosition(scene->playback_handle, cur_time);
809     if (scene->audio.flag & AUDIO_SYNC) {
810       AUD_seekSynchronizer(scene->playback_handle, cur_time);
811     }
812     AUD_Handle_resume(scene->playback_handle);
813     if (scene->sound_scrub_handle &&
814         AUD_Handle_getStatus(scene->sound_scrub_handle) != AUD_STATUS_INVALID) {
815       AUD_Handle_setPosition(scene->sound_scrub_handle, 0);
816     }
817     else {
818       if (scene->sound_scrub_handle) {
819         AUD_Handle_stop(scene->sound_scrub_handle);
820       }
821       scene->sound_scrub_handle = AUD_pauseAfter(scene->playback_handle, one_frame);
822     }
823   }
824   else {
825     if (scene->audio.flag & AUDIO_SYNC) {
826       AUD_seekSynchronizer(scene->playback_handle, cur_time);
827     }
828     else {
829       if (status == AUD_STATUS_PLAYING) {
830         AUD_Handle_setPosition(scene->playback_handle, cur_time);
831       }
832     }
833   }
834
835   AUD_Device_unlock(sound_device);
836 }
837
838 float BKE_sound_sync_scene(Scene *scene)
839 {
840   sound_verify_evaluated_id(&scene->id);
841
842   // Ugly: Blender doesn't like it when the animation is played back during rendering
843   if (G.is_rendering) {
844     return NAN_FLT;
845   }
846
847   if (scene->playback_handle) {
848     if (scene->audio.flag & AUDIO_SYNC) {
849       return AUD_getSynchronizerPosition(scene->playback_handle);
850     }
851     else {
852       return AUD_Handle_getPosition(scene->playback_handle);
853     }
854   }
855   return NAN_FLT;
856 }
857
858 int BKE_sound_scene_playing(Scene *scene)
859 {
860   sound_verify_evaluated_id(&scene->id);
861
862   // Ugly: Blender doesn't like it when the animation is played back during rendering
863   if (G.is_rendering) {
864     return -1;
865   }
866
867   // in case of a "Null" audio device, we have no playback information
868   if (AUD_Device_getRate(sound_device) == AUD_RATE_INVALID) {
869     return -1;
870   }
871
872   if (scene->audio.flag & AUDIO_SYNC) {
873     return AUD_isSynchronizerPlaying();
874   }
875   else {
876     return -1;
877   }
878 }
879
880 void BKE_sound_free_waveform(bSound *sound)
881 {
882   if ((sound->tags & SOUND_TAGS_WAVEFORM_NO_RELOAD) == 0) {
883     SoundWaveform *waveform = sound->waveform;
884     if (waveform) {
885       if (waveform->data) {
886         MEM_freeN(waveform->data);
887       }
888       MEM_freeN(waveform);
889     }
890
891     sound->waveform = NULL;
892   }
893   /* This tag is only valid once. */
894   sound->tags &= ~SOUND_TAGS_WAVEFORM_NO_RELOAD;
895 }
896
897 void BKE_sound_read_waveform(Main *bmain, bSound *sound, short *stop)
898 {
899   bool need_close_audio_handles = false;
900   if (sound->playback_handle == NULL) {
901     /* TOOD(sergey): Make it fully independent audio handle. */
902     sound_load_audio(bmain, sound);
903     need_close_audio_handles = true;
904   }
905
906   AUD_SoundInfo info = AUD_getInfo(sound->playback_handle);
907   SoundWaveform *waveform = MEM_mallocN(sizeof(SoundWaveform), "SoundWaveform");
908
909   if (info.length > 0) {
910     int length = info.length * SOUND_WAVE_SAMPLES_PER_SECOND;
911
912     waveform->data = MEM_mallocN(length * sizeof(float) * 3, "SoundWaveform.samples");
913     waveform->length = AUD_readSound(
914         sound->playback_handle, waveform->data, length, SOUND_WAVE_SAMPLES_PER_SECOND, stop);
915   }
916   else {
917     /* Create an empty waveform here if the sound couldn't be
918      * read. This indicates that reading the waveform is "done",
919      * whereas just setting sound->waveform to NULL causes other
920      * code to think the waveform still needs to be created. */
921     waveform->data = NULL;
922     waveform->length = 0;
923   }
924
925   if (*stop) {
926     if (waveform->data) {
927       MEM_freeN(waveform->data);
928     }
929     MEM_freeN(waveform);
930     BLI_spin_lock(sound->spinlock);
931     sound->tags &= ~SOUND_TAGS_WAVEFORM_LOADING;
932     BLI_spin_unlock(sound->spinlock);
933     return;
934   }
935
936   BKE_sound_free_waveform(sound);
937
938   BLI_spin_lock(sound->spinlock);
939   sound->waveform = waveform;
940   sound->tags &= ~SOUND_TAGS_WAVEFORM_LOADING;
941   BLI_spin_unlock(sound->spinlock);
942
943   if (need_close_audio_handles) {
944     sound_free_audio(sound);
945   }
946 }
947
948 static void sound_update_base(Scene *scene, Object *object, void *new_set)
949 {
950   NlaTrack *track;
951   NlaStrip *strip;
952   Speaker *speaker;
953   float quat[4];
954
955   sound_verify_evaluated_id(&scene->id);
956   sound_verify_evaluated_id(&object->id);
957
958   if ((object->type != OB_SPEAKER) || !object->adt) {
959     return;
960   }
961
962   for (track = object->adt->nla_tracks.first; track; track = track->next) {
963     for (strip = track->strips.first; strip; strip = strip->next) {
964       if (strip->type != NLASTRIP_TYPE_SOUND) {
965         continue;
966       }
967       speaker = (Speaker *)object->data;
968
969       if (AUD_removeSet(scene->speaker_handles, strip->speaker_handle)) {
970         if (speaker->sound) {
971           AUD_SequenceEntry_move(strip->speaker_handle, (double)strip->start / FPS, FLT_MAX, 0);
972         }
973         else {
974           AUD_Sequence_remove(scene->sound_scene, strip->speaker_handle);
975           strip->speaker_handle = NULL;
976         }
977       }
978       else {
979         if (speaker->sound) {
980           strip->speaker_handle = AUD_Sequence_add(scene->sound_scene,
981                                                    speaker->sound->playback_handle,
982                                                    (double)strip->start / FPS,
983                                                    FLT_MAX,
984                                                    0);
985           AUD_SequenceEntry_setRelative(strip->speaker_handle, 0);
986         }
987       }
988
989       if (strip->speaker_handle) {
990         const bool mute = ((strip->flag & NLASTRIP_FLAG_MUTED) || (speaker->flag & SPK_MUTED));
991         AUD_addSet(new_set, strip->speaker_handle);
992         AUD_SequenceEntry_setVolumeMaximum(strip->speaker_handle, speaker->volume_max);
993         AUD_SequenceEntry_setVolumeMinimum(strip->speaker_handle, speaker->volume_min);
994         AUD_SequenceEntry_setDistanceMaximum(strip->speaker_handle, speaker->distance_max);
995         AUD_SequenceEntry_setDistanceReference(strip->speaker_handle, speaker->distance_reference);
996         AUD_SequenceEntry_setAttenuation(strip->speaker_handle, speaker->attenuation);
997         AUD_SequenceEntry_setConeAngleOuter(strip->speaker_handle, speaker->cone_angle_outer);
998         AUD_SequenceEntry_setConeAngleInner(strip->speaker_handle, speaker->cone_angle_inner);
999         AUD_SequenceEntry_setConeVolumeOuter(strip->speaker_handle, speaker->cone_volume_outer);
1000
1001         mat4_to_quat(quat, object->obmat);
1002         AUD_SequenceEntry_setAnimationData(
1003             strip->speaker_handle, AUD_AP_LOCATION, CFRA, object->obmat[3], 1);
1004         AUD_SequenceEntry_setAnimationData(
1005             strip->speaker_handle, AUD_AP_ORIENTATION, CFRA, quat, 1);
1006         AUD_SequenceEntry_setAnimationData(
1007             strip->speaker_handle, AUD_AP_VOLUME, CFRA, &speaker->volume, 1);
1008         AUD_SequenceEntry_setAnimationData(
1009             strip->speaker_handle, AUD_AP_PITCH, CFRA, &speaker->pitch, 1);
1010         AUD_SequenceEntry_setSound(strip->speaker_handle, speaker->sound->playback_handle);
1011         AUD_SequenceEntry_setMuted(strip->speaker_handle, mute);
1012       }
1013     }
1014   }
1015 }
1016
1017 void BKE_sound_update_scene(Depsgraph *depsgraph, Scene *scene)
1018 {
1019   sound_verify_evaluated_id(&scene->id);
1020
1021   void *new_set = AUD_createSet();
1022   void *handle;
1023   float quat[4];
1024
1025   /* cheap test to skip looping over all objects (no speakers is a common case) */
1026   if (DEG_id_type_any_exists(depsgraph, ID_SPK)) {
1027     DEG_OBJECT_ITER_BEGIN (depsgraph,
1028                            object,
1029                            (DEG_ITER_OBJECT_FLAG_LINKED_DIRECTLY |
1030                             DEG_ITER_OBJECT_FLAG_LINKED_INDIRECTLY |
1031                             DEG_ITER_OBJECT_FLAG_LINKED_VIA_SET)) {
1032       sound_update_base(scene, object, new_set);
1033     }
1034     DEG_OBJECT_ITER_END;
1035   }
1036
1037   while ((handle = AUD_getSet(scene->speaker_handles))) {
1038     AUD_Sequence_remove(scene->sound_scene, handle);
1039   }
1040
1041   if (scene->camera) {
1042     mat4_to_quat(quat, scene->camera->obmat);
1043     AUD_Sequence_setAnimationData(
1044         scene->sound_scene, AUD_AP_LOCATION, CFRA, scene->camera->obmat[3], 1);
1045     AUD_Sequence_setAnimationData(scene->sound_scene, AUD_AP_ORIENTATION, CFRA, quat, 1);
1046   }
1047
1048   AUD_destroySet(scene->speaker_handles);
1049   scene->speaker_handles = new_set;
1050 }
1051
1052 void *BKE_sound_get_factory(void *sound)
1053 {
1054   return ((bSound *)sound)->playback_handle;
1055 }
1056
1057 float BKE_sound_get_length(Main *bmain, bSound *sound)
1058 {
1059   if (sound->playback_handle != NULL) {
1060     AUD_SoundInfo info = AUD_getInfo(sound->playback_handle);
1061     return info.length;
1062   }
1063   SoundInfo info;
1064   if (!BKE_sound_info_get(bmain, sound, &info)) {
1065     return 0.0f;
1066   }
1067   return info.length;
1068 }
1069
1070 char **BKE_sound_get_device_names(void)
1071 {
1072   if (audio_device_names == NULL) {
1073     audio_device_names = AUD_getDeviceNames();
1074   }
1075
1076   return audio_device_names;
1077 }
1078
1079 static bool sound_info_from_playback_handle(void *playback_handle, SoundInfo *sound_info)
1080 {
1081   if (playback_handle == NULL) {
1082     return false;
1083   }
1084   AUD_SoundInfo info = AUD_getInfo(playback_handle);
1085   sound_info->specs.channels = (eSoundChannels)info.specs.channels;
1086   sound_info->length = info.length;
1087   return true;
1088 }
1089
1090 bool BKE_sound_info_get(struct Main *main, struct bSound *sound, SoundInfo *sound_info)
1091 {
1092   if (sound->playback_handle != NULL) {
1093     return sound_info_from_playback_handle(sound->playback_handle, sound_info);
1094   }
1095   /* TOOD(sergey): Make it fully independent audio handle. */
1096   sound_load_audio(main, sound);
1097   const bool result = sound_info_from_playback_handle(sound->playback_handle, sound_info);
1098   sound_free_audio(sound);
1099   return result;
1100 }
1101
1102 #else /* WITH_AUDASPACE */
1103
1104 #  include "BLI_utildefines.h"
1105
1106 void BKE_sound_force_device(const char *UNUSED(device))
1107 {
1108 }
1109 void BKE_sound_init_once(void)
1110 {
1111 }
1112 void BKE_sound_init(Main *UNUSED(bmain))
1113 {
1114 }
1115 void BKE_sound_exit(void)
1116 {
1117 }
1118 void BKE_sound_exit_once(void)
1119 {
1120 }
1121 void BKE_sound_cache(bSound *UNUSED(sound))
1122 {
1123 }
1124 void BKE_sound_delete_cache(bSound *UNUSED(sound))
1125 {
1126 }
1127 void BKE_sound_load(Main *UNUSED(bmain), bSound *UNUSED(sound))
1128 {
1129 }
1130 void BKE_sound_create_scene(Scene *UNUSED(scene))
1131 {
1132 }
1133 void BKE_sound_destroy_scene(Scene *UNUSED(scene))
1134 {
1135 }
1136 void BKE_sound_reset_scene_specs(Scene *UNUSED(scene))
1137 {
1138 }
1139 void BKE_sound_mute_scene(Scene *UNUSED(scene), int UNUSED(muted))
1140 {
1141 }
1142 void *BKE_sound_scene_add_scene_sound(Scene *UNUSED(scene),
1143                                       Sequence *UNUSED(sequence),
1144                                       int UNUSED(startframe),
1145                                       int UNUSED(endframe),
1146                                       int UNUSED(frameskip))
1147 {
1148   return NULL;
1149 }
1150 void *BKE_sound_scene_add_scene_sound_defaults(Scene *UNUSED(scene), Sequence *UNUSED(sequence))
1151 {
1152   return NULL;
1153 }
1154 void *BKE_sound_add_scene_sound(Scene *UNUSED(scene),
1155                                 Sequence *UNUSED(sequence),
1156                                 int UNUSED(startframe),
1157                                 int UNUSED(endframe),
1158                                 int UNUSED(frameskip))
1159 {
1160   return NULL;
1161 }
1162 void *BKE_sound_add_scene_sound_defaults(Scene *UNUSED(scene), Sequence *UNUSED(sequence))
1163 {
1164   return NULL;
1165 }
1166 void BKE_sound_remove_scene_sound(Scene *UNUSED(scene), void *UNUSED(handle))
1167 {
1168 }
1169 void BKE_sound_mute_scene_sound(void *UNUSED(handle), char UNUSED(mute))
1170 {
1171 }
1172 void BKE_sound_move_scene_sound(Scene *UNUSED(scene),
1173                                 void *UNUSED(handle),
1174                                 int UNUSED(startframe),
1175                                 int UNUSED(endframe),
1176                                 int UNUSED(frameskip))
1177 {
1178 }
1179 void BKE_sound_move_scene_sound_defaults(Scene *UNUSED(scene), Sequence *UNUSED(sequence))
1180 {
1181 }
1182 void BKE_sound_play_scene(Scene *UNUSED(scene))
1183 {
1184 }
1185 void BKE_sound_stop_scene(Scene *UNUSED(scene))
1186 {
1187 }
1188 void BKE_sound_seek_scene(Main *UNUSED(bmain), Scene *UNUSED(scene))
1189 {
1190 }
1191 float BKE_sound_sync_scene(Scene *UNUSED(scene))
1192 {
1193   return NAN_FLT;
1194 }
1195 int BKE_sound_scene_playing(Scene *UNUSED(scene))
1196 {
1197   return -1;
1198 }
1199 void BKE_sound_read_waveform(Main *bmain, bSound *sound, short *stop)
1200 {
1201   UNUSED_VARS(sound, stop, bmain);
1202 }
1203 void BKE_sound_init_main(Main *UNUSED(bmain))
1204 {
1205 }
1206 void BKE_sound_set_cfra(int UNUSED(cfra))
1207 {
1208 }
1209 void BKE_sound_update_sequencer(Main *UNUSED(main), bSound *UNUSED(sound))
1210 {
1211 }
1212 void BKE_sound_update_scene(Depsgraph *UNUSED(depsgraph), Scene *UNUSED(scene))
1213 {
1214 }
1215 void BKE_sound_update_scene_sound(void *UNUSED(handle), bSound *UNUSED(sound))
1216 {
1217 }
1218 void BKE_sound_update_scene_listener(Scene *UNUSED(scene))
1219 {
1220 }
1221 void BKE_sound_update_fps(Main *UNUSED(bmain), Scene *UNUSED(scene))
1222 {
1223 }
1224 void BKE_sound_set_scene_sound_volume(void *UNUSED(handle),
1225                                       float UNUSED(volume),
1226                                       char UNUSED(animated))
1227 {
1228 }
1229 void BKE_sound_set_scene_sound_pan(void *UNUSED(handle), float UNUSED(pan), char UNUSED(animated))
1230 {
1231 }
1232 void BKE_sound_set_scene_volume(Scene *UNUSED(scene), float UNUSED(volume))
1233 {
1234 }
1235 void BKE_sound_set_scene_sound_pitch(void *UNUSED(handle),
1236                                      float UNUSED(pitch),
1237                                      char UNUSED(animated))
1238 {
1239 }
1240 float BKE_sound_get_length(struct Main *UNUSED(bmain), bSound *UNUSED(sound))
1241 {
1242   return 0;
1243 }
1244 char **BKE_sound_get_device_names(void)
1245 {
1246   static char *names[1] = {NULL};
1247   return names;
1248 }
1249
1250 void BKE_sound_free_waveform(bSound *UNUSED(sound))
1251 {
1252 }
1253
1254 bool BKE_sound_info_get(struct Main *UNUSED(main),
1255                         struct bSound *UNUSED(sound),
1256                         SoundInfo *UNUSED(sound_info))
1257 {
1258   return false;
1259 }
1260
1261 #endif /* WITH_AUDASPACE */
1262
1263 void BKE_sound_reset_scene_runtime(Scene *scene)
1264 {
1265   scene->sound_scene = NULL;
1266   scene->playback_handle = NULL;
1267   scene->sound_scrub_handle = NULL;
1268   scene->speaker_handles = NULL;
1269 }
1270
1271 void BKE_sound_ensure_scene(struct Scene *scene)
1272 {
1273   if (scene->sound_scene != NULL) {
1274     return;
1275   }
1276   BKE_sound_create_scene(scene);
1277 }
1278
1279 void BKE_sound_reset_runtime(bSound *sound)
1280 {
1281   sound->cache = NULL;
1282   sound->playback_handle = NULL;
1283 }
1284
1285 void BKE_sound_ensure_loaded(Main *bmain, bSound *sound)
1286 {
1287   if (sound->cache != NULL) {
1288     return;
1289   }
1290   BKE_sound_load(bmain, sound);
1291 }
1292
1293 void BKE_sound_jack_sync_callback_set(SoundJackSyncCallback callback)
1294 {
1295 #if defined(WITH_AUDASPACE) && defined(WITH_JACK)
1296   sound_jack_sync_callback = callback;
1297 #else
1298   UNUSED_VARS(callback);
1299 #endif
1300 }
1301
1302 void BKE_sound_jack_scene_update(Scene *scene, int mode, float time)
1303 {
1304   sound_verify_evaluated_id(&scene->id);
1305
1306   /* Ugly: Blender doesn't like it when the animation is played back during rendering. */
1307   if (G.is_rendering) {
1308     return;
1309   }
1310
1311   if (mode) {
1312     BKE_sound_play_scene(scene);
1313   }
1314   else {
1315     BKE_sound_stop_scene(scene);
1316   }
1317 #ifdef WITH_AUDASPACE
1318   if (scene->playback_handle != NULL) {
1319     AUD_Handle_setPosition(scene->playback_handle, time);
1320   }
1321 #else
1322   UNUSED_VARS(time);
1323 #endif
1324 }
1325
1326 void BKE_sound_evaluate(Depsgraph *depsgraph, Main *bmain, bSound *sound)
1327 {
1328   DEG_debug_print_eval(depsgraph, __func__, sound->id.name, sound);
1329   if (sound->id.recalc & ID_RECALC_AUDIO) {
1330     BKE_sound_load(bmain, sound);
1331     return;
1332   }
1333   BKE_sound_ensure_loaded(bmain, sound);
1334 }