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