eeef658c0649b7348c4a74330ebf3a85e6842832
[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   const double fps = FPS;
609   void *handle = AUD_Sequence_add(scene->sound_scene,
610                                   sequence->sound->playback_handle,
611                                   startframe / fps,
612                                   endframe / fps,
613                                   frameskip / fps);
614   AUD_SequenceEntry_setMuted(handle, (sequence->flag & SEQ_MUTE) != 0);
615   AUD_SequenceEntry_setAnimationData(handle, AUD_AP_VOLUME, CFRA, &sequence->volume, 0);
616   AUD_SequenceEntry_setAnimationData(handle, AUD_AP_PITCH, CFRA, &sequence->pitch, 0);
617   AUD_SequenceEntry_setAnimationData(handle, AUD_AP_PANNING, CFRA, &sequence->pan, 0);
618   return handle;
619 }
620
621 void *BKE_sound_add_scene_sound_defaults(Scene *scene, Sequence *sequence)
622 {
623   return BKE_sound_add_scene_sound(scene,
624                                    sequence,
625                                    sequence->startdisp,
626                                    sequence->enddisp,
627                                    sequence->startofs + sequence->anim_startofs);
628 }
629
630 void BKE_sound_remove_scene_sound(Scene *scene, void *handle)
631 {
632   AUD_Sequence_remove(scene->sound_scene, handle);
633 }
634
635 void BKE_sound_mute_scene_sound(void *handle, char mute)
636 {
637   AUD_SequenceEntry_setMuted(handle, mute);
638 }
639
640 void BKE_sound_move_scene_sound(
641     Scene *scene, void *handle, int startframe, int endframe, int frameskip)
642 {
643   sound_verify_evaluated_id(&scene->id);
644   const double fps = FPS;
645   AUD_SequenceEntry_move(handle, startframe / fps, endframe / fps, frameskip / fps);
646 }
647
648 void BKE_sound_move_scene_sound_defaults(Scene *scene, Sequence *sequence)
649 {
650   sound_verify_evaluated_id(&scene->id);
651   if (sequence->scene_sound) {
652     BKE_sound_move_scene_sound(scene,
653                                sequence->scene_sound,
654                                sequence->startdisp,
655                                sequence->enddisp,
656                                sequence->startofs + sequence->anim_startofs);
657   }
658 }
659
660 void BKE_sound_update_scene_sound(void *handle, bSound *sound)
661 {
662   AUD_SequenceEntry_setSound(handle, sound->playback_handle);
663 }
664
665 void BKE_sound_set_cfra(int cfra)
666 {
667   sound_cfra = cfra;
668 }
669
670 void BKE_sound_set_scene_volume(Scene *scene, float volume)
671 {
672   sound_verify_evaluated_id(&scene->id);
673   AUD_Sequence_setAnimationData(scene->sound_scene,
674                                 AUD_AP_VOLUME,
675                                 CFRA,
676                                 &volume,
677                                 (scene->audio.flag & AUDIO_VOLUME_ANIMATED) != 0);
678 }
679
680 void BKE_sound_set_scene_sound_volume(void *handle, float volume, char animated)
681 {
682   AUD_SequenceEntry_setAnimationData(handle, AUD_AP_VOLUME, sound_cfra, &volume, animated);
683 }
684
685 void BKE_sound_set_scene_sound_pitch(void *handle, float pitch, char animated)
686 {
687   AUD_SequenceEntry_setAnimationData(handle, AUD_AP_PITCH, sound_cfra, &pitch, animated);
688 }
689
690 void BKE_sound_set_scene_sound_pan(void *handle, float pan, char animated)
691 {
692   AUD_SequenceEntry_setAnimationData(handle, AUD_AP_PANNING, sound_cfra, &pan, animated);
693 }
694
695 void BKE_sound_update_sequencer(Main *main, bSound *sound)
696 {
697   BLI_assert(!"is not supposed to be used, is weird function.");
698
699   Scene *scene;
700
701   for (scene = main->scenes.first; scene; scene = scene->id.next) {
702     BKE_sequencer_update_sound(scene, sound);
703   }
704 }
705
706 static void sound_start_play_scene(Scene *scene)
707 {
708   sound_verify_evaluated_id(&scene->id);
709
710   if (scene->playback_handle) {
711     AUD_Handle_stop(scene->playback_handle);
712   }
713
714   BKE_sound_reset_scene_specs(scene);
715
716   if ((scene->playback_handle = AUD_Device_play(sound_device, scene->sound_scene, 1))) {
717     AUD_Handle_setLoopCount(scene->playback_handle, -1);
718   }
719 }
720
721 void BKE_sound_play_scene(Scene *scene)
722 {
723   sound_verify_evaluated_id(&scene->id);
724
725   AUD_Status status;
726   const float cur_time = (float)((double)CFRA / FPS);
727
728   AUD_Device_lock(sound_device);
729
730   status = scene->playback_handle ? AUD_Handle_getStatus(scene->playback_handle) :
731                                     AUD_STATUS_INVALID;
732
733   if (status == AUD_STATUS_INVALID) {
734     sound_start_play_scene(scene);
735
736     if (!scene->playback_handle) {
737       AUD_Device_unlock(sound_device);
738       return;
739     }
740   }
741
742   if (status != AUD_STATUS_PLAYING) {
743     AUD_Handle_setPosition(scene->playback_handle, cur_time);
744     AUD_Handle_resume(scene->playback_handle);
745   }
746
747   if (scene->audio.flag & AUDIO_SYNC) {
748     AUD_playSynchronizer();
749   }
750
751   AUD_Device_unlock(sound_device);
752 }
753
754 void BKE_sound_stop_scene(Scene *scene)
755 {
756   if (scene->playback_handle) {
757     AUD_Handle_pause(scene->playback_handle);
758
759     if (scene->audio.flag & AUDIO_SYNC) {
760       AUD_stopSynchronizer();
761     }
762   }
763 }
764
765 void BKE_sound_seek_scene(Main *bmain, Scene *scene)
766 {
767   sound_verify_evaluated_id(&scene->id);
768
769   AUD_Status status;
770   bScreen *screen;
771   int animation_playing;
772
773   const float one_frame = (float)(1.0 / FPS);
774   const float cur_time = (float)((double)CFRA / FPS);
775
776   AUD_Device_lock(sound_device);
777
778   status = scene->playback_handle ? AUD_Handle_getStatus(scene->playback_handle) :
779                                     AUD_STATUS_INVALID;
780
781   if (status == AUD_STATUS_INVALID) {
782     sound_start_play_scene(scene);
783
784     if (!scene->playback_handle) {
785       AUD_Device_unlock(sound_device);
786       return;
787     }
788
789     AUD_Handle_pause(scene->playback_handle);
790   }
791
792   animation_playing = 0;
793   for (screen = bmain->screens.first; screen; screen = screen->id.next) {
794     if (screen->animtimer) {
795       animation_playing = 1;
796       break;
797     }
798   }
799
800   if (scene->audio.flag & AUDIO_SCRUB && !animation_playing) {
801     AUD_Handle_setPosition(scene->playback_handle, cur_time);
802     if (scene->audio.flag & AUDIO_SYNC) {
803       AUD_seekSynchronizer(scene->playback_handle, cur_time);
804     }
805     AUD_Handle_resume(scene->playback_handle);
806     if (scene->sound_scrub_handle &&
807         AUD_Handle_getStatus(scene->sound_scrub_handle) != AUD_STATUS_INVALID) {
808       AUD_Handle_setPosition(scene->sound_scrub_handle, 0);
809     }
810     else {
811       if (scene->sound_scrub_handle) {
812         AUD_Handle_stop(scene->sound_scrub_handle);
813       }
814       scene->sound_scrub_handle = AUD_pauseAfter(scene->playback_handle, one_frame);
815     }
816   }
817   else {
818     if (scene->audio.flag & AUDIO_SYNC) {
819       AUD_seekSynchronizer(scene->playback_handle, cur_time);
820     }
821     else {
822       if (status == AUD_STATUS_PLAYING) {
823         AUD_Handle_setPosition(scene->playback_handle, cur_time);
824       }
825     }
826   }
827
828   AUD_Device_unlock(sound_device);
829 }
830
831 float BKE_sound_sync_scene(Scene *scene)
832 {
833   sound_verify_evaluated_id(&scene->id);
834
835   // Ugly: Blender doesn't like it when the animation is played back during rendering
836   if (G.is_rendering) {
837     return NAN_FLT;
838   }
839
840   if (scene->playback_handle) {
841     if (scene->audio.flag & AUDIO_SYNC) {
842       return AUD_getSynchronizerPosition(scene->playback_handle);
843     }
844     else {
845       return AUD_Handle_getPosition(scene->playback_handle);
846     }
847   }
848   return NAN_FLT;
849 }
850
851 int BKE_sound_scene_playing(Scene *scene)
852 {
853   sound_verify_evaluated_id(&scene->id);
854
855   // Ugly: Blender doesn't like it when the animation is played back during rendering
856   if (G.is_rendering) {
857     return -1;
858   }
859
860   // in case of a "Null" audio device, we have no playback information
861   if (AUD_Device_getRate(sound_device) == AUD_RATE_INVALID) {
862     return -1;
863   }
864
865   if (scene->audio.flag & AUDIO_SYNC) {
866     return AUD_isSynchronizerPlaying();
867   }
868   else {
869     return -1;
870   }
871 }
872
873 void BKE_sound_free_waveform(bSound *sound)
874 {
875   if ((sound->tags & SOUND_TAGS_WAVEFORM_NO_RELOAD) == 0) {
876     SoundWaveform *waveform = sound->waveform;
877     if (waveform) {
878       if (waveform->data) {
879         MEM_freeN(waveform->data);
880       }
881       MEM_freeN(waveform);
882     }
883
884     sound->waveform = NULL;
885   }
886   /* This tag is only valid once. */
887   sound->tags &= ~SOUND_TAGS_WAVEFORM_NO_RELOAD;
888 }
889
890 /* TODO(sergey): Consider mamakinging this function fully autonomous, as in, not require having
891  * an existing playback handle. That would make it easy to read waveforms, which doesn't seem to
892  * be affected by evaluated scene (waveworm comes from file). */
893 void BKE_sound_read_waveform(bSound *sound, short *stop)
894 {
895   AUD_SoundInfo info = AUD_getInfo(sound->playback_handle);
896   SoundWaveform *waveform = MEM_mallocN(sizeof(SoundWaveform), "SoundWaveform");
897
898   if (info.length > 0) {
899     int length = info.length * SOUND_WAVE_SAMPLES_PER_SECOND;
900
901     waveform->data = MEM_mallocN(length * sizeof(float) * 3, "SoundWaveform.samples");
902     waveform->length = AUD_readSound(
903         sound->playback_handle, waveform->data, length, SOUND_WAVE_SAMPLES_PER_SECOND, stop);
904   }
905   else {
906     /* Create an empty waveform here if the sound couldn't be
907      * read. This indicates that reading the waveform is "done",
908      * whereas just setting sound->waveform to NULL causes other
909      * code to think the waveform still needs to be created. */
910     waveform->data = NULL;
911     waveform->length = 0;
912   }
913
914   if (*stop) {
915     if (waveform->data) {
916       MEM_freeN(waveform->data);
917     }
918     MEM_freeN(waveform);
919     BLI_spin_lock(sound->spinlock);
920     sound->tags &= ~SOUND_TAGS_WAVEFORM_LOADING;
921     BLI_spin_unlock(sound->spinlock);
922     return;
923   }
924
925   BKE_sound_free_waveform(sound);
926
927   BLI_spin_lock(sound->spinlock);
928   sound->waveform = waveform;
929   sound->tags &= ~SOUND_TAGS_WAVEFORM_LOADING;
930   BLI_spin_unlock(sound->spinlock);
931 }
932
933 static void sound_update_base(Scene *scene, Base *base, void *new_set)
934 {
935   Object *ob = base->object;
936   NlaTrack *track;
937   NlaStrip *strip;
938   Speaker *speaker;
939   float quat[4];
940
941   sound_verify_evaluated_id(&scene->id);
942   sound_verify_evaluated_id(&ob->id);
943
944   if ((ob->type != OB_SPEAKER) || !ob->adt) {
945     return;
946   }
947
948   for (track = ob->adt->nla_tracks.first; track; track = track->next) {
949     for (strip = track->strips.first; strip; strip = strip->next) {
950       if (strip->type != NLASTRIP_TYPE_SOUND) {
951         continue;
952       }
953       speaker = (Speaker *)ob->data;
954
955       if (AUD_removeSet(scene->speaker_handles, strip->speaker_handle)) {
956         if (speaker->sound) {
957           AUD_SequenceEntry_move(strip->speaker_handle, (double)strip->start / FPS, FLT_MAX, 0);
958         }
959         else {
960           AUD_Sequence_remove(scene->sound_scene, strip->speaker_handle);
961           strip->speaker_handle = NULL;
962         }
963       }
964       else {
965         if (speaker->sound) {
966           strip->speaker_handle = AUD_Sequence_add(scene->sound_scene,
967                                                    speaker->sound->playback_handle,
968                                                    (double)strip->start / FPS,
969                                                    FLT_MAX,
970                                                    0);
971           AUD_SequenceEntry_setRelative(strip->speaker_handle, 0);
972         }
973       }
974
975       if (strip->speaker_handle) {
976         const bool mute = ((strip->flag & NLASTRIP_FLAG_MUTED) || (speaker->flag & SPK_MUTED));
977         AUD_addSet(new_set, strip->speaker_handle);
978         AUD_SequenceEntry_setVolumeMaximum(strip->speaker_handle, speaker->volume_max);
979         AUD_SequenceEntry_setVolumeMinimum(strip->speaker_handle, speaker->volume_min);
980         AUD_SequenceEntry_setDistanceMaximum(strip->speaker_handle, speaker->distance_max);
981         AUD_SequenceEntry_setDistanceReference(strip->speaker_handle, speaker->distance_reference);
982         AUD_SequenceEntry_setAttenuation(strip->speaker_handle, speaker->attenuation);
983         AUD_SequenceEntry_setConeAngleOuter(strip->speaker_handle, speaker->cone_angle_outer);
984         AUD_SequenceEntry_setConeAngleInner(strip->speaker_handle, speaker->cone_angle_inner);
985         AUD_SequenceEntry_setConeVolumeOuter(strip->speaker_handle, speaker->cone_volume_outer);
986
987         mat4_to_quat(quat, ob->obmat);
988         AUD_SequenceEntry_setAnimationData(
989             strip->speaker_handle, AUD_AP_LOCATION, CFRA, ob->obmat[3], 1);
990         AUD_SequenceEntry_setAnimationData(
991             strip->speaker_handle, AUD_AP_ORIENTATION, CFRA, quat, 1);
992         AUD_SequenceEntry_setAnimationData(
993             strip->speaker_handle, AUD_AP_VOLUME, CFRA, &speaker->volume, 1);
994         AUD_SequenceEntry_setAnimationData(
995             strip->speaker_handle, AUD_AP_PITCH, CFRA, &speaker->pitch, 1);
996         AUD_SequenceEntry_setSound(strip->speaker_handle, speaker->sound->playback_handle);
997         AUD_SequenceEntry_setMuted(strip->speaker_handle, mute);
998       }
999     }
1000   }
1001 }
1002
1003 void BKE_sound_update_scene(Depsgraph *depsgraph, Scene *scene)
1004 {
1005   sound_verify_evaluated_id(&scene->id);
1006
1007   Base *base;
1008   Scene *sce_it;
1009
1010   void *new_set = AUD_createSet();
1011   void *handle;
1012   float quat[4];
1013
1014   /* cheap test to skip looping over all objects (no speakers is a common case) */
1015   if (DEG_id_type_any_exists(depsgraph, ID_SPK)) {
1016     for (ViewLayer *view_layer = scene->view_layers.first; view_layer;
1017          view_layer = view_layer->next) {
1018       for (base = view_layer->object_bases.first; base; base = base->next) {
1019         sound_update_base(scene, base, new_set);
1020       }
1021     }
1022
1023     for (SETLOOPER_SET_ONLY(scene, sce_it, base)) {
1024       sound_update_base(scene, base, new_set);
1025     }
1026   }
1027
1028   while ((handle = AUD_getSet(scene->speaker_handles))) {
1029     AUD_Sequence_remove(scene->sound_scene, handle);
1030   }
1031
1032   if (scene->camera) {
1033     mat4_to_quat(quat, scene->camera->obmat);
1034     AUD_Sequence_setAnimationData(
1035         scene->sound_scene, AUD_AP_LOCATION, CFRA, scene->camera->obmat[3], 1);
1036     AUD_Sequence_setAnimationData(scene->sound_scene, AUD_AP_ORIENTATION, CFRA, quat, 1);
1037   }
1038
1039   AUD_destroySet(scene->speaker_handles);
1040   scene->speaker_handles = new_set;
1041 }
1042
1043 void *BKE_sound_get_factory(void *sound)
1044 {
1045   return ((bSound *)sound)->playback_handle;
1046 }
1047
1048 /* stupid wrapper because AUD_C-API.h includes Python.h which makesrna doesn't like */
1049 float BKE_sound_get_length(bSound *sound)
1050 {
1051   sound_verify_evaluated_id(&sound->id);
1052   AUD_SoundInfo info = AUD_getInfo(sound->playback_handle);
1053
1054   return info.length;
1055 }
1056
1057 char **BKE_sound_get_device_names(void)
1058 {
1059   if (audio_device_names == NULL) {
1060     audio_device_names = AUD_getDeviceNames();
1061   }
1062
1063   return audio_device_names;
1064 }
1065
1066 #else /* WITH_AUDASPACE */
1067
1068 #  include "BLI_utildefines.h"
1069
1070 void BKE_sound_force_device(const char *UNUSED(device))
1071 {
1072 }
1073 void BKE_sound_init_once(void)
1074 {
1075 }
1076 void BKE_sound_init(Main *UNUSED(bmain))
1077 {
1078 }
1079 void BKE_sound_exit(void)
1080 {
1081 }
1082 void BKE_sound_exit_once(void)
1083 {
1084 }
1085 void BKE_sound_cache(bSound *UNUSED(sound))
1086 {
1087 }
1088 void BKE_sound_delete_cache(bSound *UNUSED(sound))
1089 {
1090 }
1091 void BKE_sound_load(Main *UNUSED(bmain), bSound *UNUSED(sound))
1092 {
1093 }
1094 void BKE_sound_create_scene(Scene *UNUSED(scene))
1095 {
1096 }
1097 void BKE_sound_destroy_scene(Scene *UNUSED(scene))
1098 {
1099 }
1100 void BKE_sound_reset_scene_specs(Scene *UNUSED(scene))
1101 {
1102 }
1103 void BKE_sound_mute_scene(Scene *UNUSED(scene), int UNUSED(muted))
1104 {
1105 }
1106 void *BKE_sound_scene_add_scene_sound(Scene *UNUSED(scene),
1107                                       Sequence *UNUSED(sequence),
1108                                       int UNUSED(startframe),
1109                                       int UNUSED(endframe),
1110                                       int UNUSED(frameskip))
1111 {
1112   return NULL;
1113 }
1114 void *BKE_sound_scene_add_scene_sound_defaults(Scene *UNUSED(scene), Sequence *UNUSED(sequence))
1115 {
1116   return NULL;
1117 }
1118 void *BKE_sound_add_scene_sound(Scene *UNUSED(scene),
1119                                 Sequence *UNUSED(sequence),
1120                                 int UNUSED(startframe),
1121                                 int UNUSED(endframe),
1122                                 int UNUSED(frameskip))
1123 {
1124   return NULL;
1125 }
1126 void *BKE_sound_add_scene_sound_defaults(Scene *UNUSED(scene), Sequence *UNUSED(sequence))
1127 {
1128   return NULL;
1129 }
1130 void BKE_sound_remove_scene_sound(Scene *UNUSED(scene), void *UNUSED(handle))
1131 {
1132 }
1133 void BKE_sound_mute_scene_sound(void *UNUSED(handle), char UNUSED(mute))
1134 {
1135 }
1136 void BKE_sound_move_scene_sound(Scene *UNUSED(scene),
1137                                 void *UNUSED(handle),
1138                                 int UNUSED(startframe),
1139                                 int UNUSED(endframe),
1140                                 int UNUSED(frameskip))
1141 {
1142 }
1143 void BKE_sound_move_scene_sound_defaults(Scene *UNUSED(scene), Sequence *UNUSED(sequence))
1144 {
1145 }
1146 void BKE_sound_play_scene(Scene *UNUSED(scene))
1147 {
1148 }
1149 void BKE_sound_stop_scene(Scene *UNUSED(scene))
1150 {
1151 }
1152 void BKE_sound_seek_scene(Main *UNUSED(bmain), Scene *UNUSED(scene))
1153 {
1154 }
1155 float BKE_sound_sync_scene(Scene *UNUSED(scene))
1156 {
1157   return NAN_FLT;
1158 }
1159 int BKE_sound_scene_playing(Scene *UNUSED(scene))
1160 {
1161   return -1;
1162 }
1163 void BKE_sound_read_waveform(bSound *sound, short *stop)
1164 {
1165   UNUSED_VARS(sound, stop);
1166 }
1167 void BKE_sound_init_main(Main *UNUSED(bmain))
1168 {
1169 }
1170 void BKE_sound_set_cfra(int UNUSED(cfra))
1171 {
1172 }
1173 void BKE_sound_update_sequencer(Main *UNUSED(main), bSound *UNUSED(sound))
1174 {
1175 }
1176 void BKE_sound_update_scene(Depsgraph *UNUSED(depsgraph), Scene *UNUSED(scene))
1177 {
1178 }
1179 void BKE_sound_update_scene_sound(void *UNUSED(handle), bSound *UNUSED(sound))
1180 {
1181 }
1182 void BKE_sound_update_scene_listener(Scene *UNUSED(scene))
1183 {
1184 }
1185 void BKE_sound_update_fps(Scene *UNUSED(scene))
1186 {
1187 }
1188 void BKE_sound_set_scene_sound_volume(void *UNUSED(handle),
1189                                       float UNUSED(volume),
1190                                       char UNUSED(animated))
1191 {
1192 }
1193 void BKE_sound_set_scene_sound_pan(void *UNUSED(handle), float UNUSED(pan), char UNUSED(animated))
1194 {
1195 }
1196 void BKE_sound_set_scene_volume(Scene *UNUSED(scene), float UNUSED(volume))
1197 {
1198 }
1199 void BKE_sound_set_scene_sound_pitch(void *UNUSED(handle),
1200                                      float UNUSED(pitch),
1201                                      char UNUSED(animated))
1202 {
1203 }
1204 float BKE_sound_get_length(bSound *UNUSED(sound))
1205 {
1206   return 0;
1207 }
1208 char **BKE_sound_get_device_names(void)
1209 {
1210   static char *names[1] = {NULL};
1211   return names;
1212 }
1213
1214 void BKE_sound_free_waveform(bSound *UNUSED(sound))
1215 {
1216 }
1217
1218 void BKE_sound_load_audio(Main *UNUSED(bmain), bSound *UNUSED(sound))
1219 {
1220 }
1221
1222 #endif /* WITH_AUDASPACE */
1223
1224 void BKE_sound_reset_scene_runtime(Scene *scene)
1225 {
1226   scene->sound_scene = NULL;
1227   scene->playback_handle = NULL;
1228   scene->sound_scrub_handle = NULL;
1229   scene->speaker_handles = NULL;
1230 }
1231
1232 void BKE_sound_ensure_scene(struct Scene *scene)
1233 {
1234   if (scene->sound_scene != NULL) {
1235     return;
1236   }
1237   BKE_sound_create_scene(scene);
1238 }
1239
1240 void BKE_sound_reset_runtime(bSound *sound)
1241 {
1242   sound->cache = NULL;
1243   sound->playback_handle = NULL;
1244 }
1245
1246 void BKE_sound_ensure_loaded(Main *bmain, bSound *sound)
1247 {
1248   if (sound->cache != NULL) {
1249     return;
1250   }
1251   BKE_sound_load(bmain, sound);
1252 }
1253
1254 void BKE_sound_jack_sync_callback_set(SoundJackSyncCallback callback)
1255 {
1256 #if defined(WITH_AUDASPACE) && defined(WITH_JACK)
1257   sound_jack_sync_callback = callback;
1258 #else
1259   UNUSED_VARS(callback);
1260 #endif
1261 }
1262
1263 void BKE_sound_jack_scene_update(Scene *scene, int mode, float time)
1264 {
1265   sound_verify_evaluated_id(&scene->id);
1266
1267   /* Ugly: Blender doesn't like it when the animation is played back during rendering. */
1268   if (G.is_rendering) {
1269     return;
1270   }
1271
1272   if (mode) {
1273     BKE_sound_play_scene(scene);
1274   }
1275   else {
1276     BKE_sound_stop_scene(scene);
1277   }
1278 #ifdef WITH_AUDASPACE
1279   if (scene->playback_handle != NULL) {
1280     AUD_Handle_setPosition(scene->playback_handle, time);
1281   }
1282 #else
1283   UNUSED_VARS(time);
1284 #endif
1285 }
1286
1287 void BKE_sound_evaluate(Depsgraph *depsgraph, Main *bmain, bSound *sound)
1288 {
1289   DEG_debug_print_eval(depsgraph, __func__, sound->id.name, sound);
1290   BKE_sound_ensure_loaded(bmain, sound);
1291 }