source/blender/blenkernel/intern/sound.c

   1 /**
   2  * sound.c (mar-2001 nzc)
   3  *
   4  * $Id$
   5  */
   6
   7 #include <string.h>
   8 #include <stdlib.h>
   9
  10 #include "MEM_guardedalloc.h"
  11
  12 #include "BLI_blenlib.h"
  13
  14 #include "DNA_scene_types.h"
  15 #include "DNA_sound_types.h"
  16 #include "DNA_packedFile_types.h"
  17 #include "DNA_screen_types.h"
  18 #include "DNA_userdef_types.h"
  19
  20 #include "AUD_C-API.h"
  21
  22 #include "BKE_utildefines.h"
  23 #include "BKE_global.h"
  24 #include "BKE_main.h"
  25 #include "BKE_sound.h"
  26 #include "BKE_context.h"
  27 #include "BKE_library.h"
  28 #include "BKE_packedFile.h"
  29
  30 #ifdef HAVE_CONFIG_H
  31 #include <config.h>
  32 #endif
  33
  34 void sound_init()
  35 {
  36         AUD_Specs specs;
  37         int device, buffersize, success;
  38
  39         device = U.audiodevice;
  40         buffersize = U.mixbufsize;
  41         specs.channels = U.audiochannels;
  42         specs.format = U.audioformat;
  43         specs.rate = U.audiorate;
  44
  45         if(buffersize < 128)
  46                 buffersize = AUD_DEFAULT_BUFFER_SIZE;
  47
  48         if(specs.rate < AUD_RATE_8000)
  49                 specs.rate = AUD_RATE_44100;
  50
  51         if(specs.format <= AUD_FORMAT_INVALID)
  52                 specs.format = AUD_FORMAT_S16;
  53
  54         if(specs.channels <= AUD_CHANNELS_INVALID)
  55                 specs.channels = AUD_CHANNELS_STEREO;
  56
  57         if(!AUD_init(device, specs, buffersize)) {
  58                 if(device == AUD_SDL_DEVICE)
  59                         success= AUD_init(AUD_OPENAL_DEVICE, specs, AUD_DEFAULT_BUFFER_SIZE*4);
  60                 else
  61                         success= AUD_init(AUD_SDL_DEVICE, specs, AUD_DEFAULT_BUFFER_SIZE*4);
  62
  63                 if(!success)
  64                         AUD_init(AUD_NULL_DEVICE, specs, buffersize);
  65         }
  66 }
  67
  68 void sound_exit()
  69 {
  70         AUD_exit();
  71 }
  72
  73 struct bSound* sound_new_file(struct Main *main, char* filename)
  74 {
  75         bSound* sound = NULL;
  76
  77         char str[FILE_MAX];
  78         int len;
  79
  80         strcpy(str, filename);
  81         BLI_convertstringcode(str, G.sce);
  82
  83         len = strlen(filename);
  84         while(len > 0 && filename[len-1] != '/' && filename[len-1] != '\\')
  85                 len--;
  86
  87         sound = alloc_libblock(&main->sound, ID_SO, filename+len);
  88         strcpy(sound->name, filename);
  89         sound->type = SOUND_TYPE_FILE;
  90
  91         sound_load(sound);
  92
  93         if(!sound->snd_sound)
  94         {
  95                 free_libblock(&main->sound, sound);
  96                 sound = NULL;
  97         }
  98
  99         return sound;
 100 }
 101
 102 // XXX unused currently
 103 #if 0
 104 struct bSound* sound_new_buffer(struct bContext *C, struct bSound *source)
 105 {
 106         bSound* sound = NULL;
 107
 108         char name[25];
 109         strcpy(name, "buf_");
 110         strcpy(name + 4, source->id.name);
 111
 112         sound = alloc_libblock(&CTX_data_main(C)->sound, ID_SO, name);
 113
 114         sound->child_sound = source;
 115         sound->type = SOUND_TYPE_BUFFER;
 116
 117         sound_load(sound);
 118
 119         if(!sound->snd_sound)
 120         {
 121                 free_libblock(&CTX_data_main(C)->sound, sound);
 122                 sound = NULL;
 123         }
 124
 125         return sound;
 126 }
 127
 128 struct bSound* sound_new_limiter(struct bContext *C, struct bSound *source, float start, float end)
 129 {
 130         bSound* sound = NULL;
 131
 132         char name[25];
 133         strcpy(name, "lim_");
 134         strcpy(name + 4, source->id.name);
 135
 136         sound = alloc_libblock(&CTX_data_main(C)->sound, ID_SO, name);
 137
 138         sound->child_sound = source;
 139         sound->start = start;
 140         sound->end = end;
 141         sound->type = SOUND_TYPE_LIMITER;
 142
 143         sound_load(sound);
 144
 145         if(!sound->snd_sound)
 146         {
 147                 free_libblock(&CTX_data_main(C)->sound, sound);
 148                 sound = NULL;
 149         }
 150
 151         return sound;
 152 }
 153 #endif
 154
 155 void sound_delete(struct bContext *C, struct bSound* sound)
 156 {
 157         if(sound)
 158         {
 159                 sound_free(sound);
 160
 161                 sound_unlink(C, sound);
 162
 163                 free_libblock(&CTX_data_main(C)->sound, sound);
 164         }
 165 }
 166
 167 void sound_cache(struct bSound* sound, int ignore)
 168 {
 169         if(sound->cache && !ignore)
 170                 AUD_unload(sound->cache);
 171
 172         sound->cache = AUD_bufferSound(sound->snd_sound);
 173 }
 174
 175 void sound_load(struct bSound* sound)
 176 {
 177         if(sound)
 178         {
 179                 if(sound->snd_sound)
 180                 {
 181                         AUD_unload(sound->snd_sound);
 182                         sound->snd_sound = NULL;
 183                 }
 184
 185                 switch(sound->type)
 186                 {
 187                 case SOUND_TYPE_FILE:
 188                 {
 189                         char fullpath[FILE_MAX];
 190                         char *path;
 191
 192                         /* load sound */
 193                         PackedFile* pf = sound->packedfile;
 194
 195                         /* dont modify soundact->sound->name, only change a copy */
 196                         BLI_strncpy(fullpath, sound->name, sizeof(fullpath));
 197
 198                         if(sound->id.lib)
 199                                 path = sound->id.lib->filename;
 200                         else
 201                                 path = G.sce;
 202
 203                         BLI_convertstringcode(fullpath, path);
 204
 205                         /* but we need a packed file then */
 206                         if (pf)
 207                                 sound->snd_sound = AUD_loadBuffer((unsigned char*) pf->data, pf->size);
 208                         /* or else load it from disk */
 209                         else
 210                                 sound->snd_sound = AUD_load(fullpath);
 211                         break;
 212                 }
 213                 case SOUND_TYPE_BUFFER:
 214                         if(sound->child_sound && sound->child_sound->snd_sound)
 215                                 sound->snd_sound = AUD_bufferSound(sound->child_sound->snd_sound);
 216                         break;
 217                 case SOUND_TYPE_LIMITER:
 218                         if(sound->child_sound && sound->child_sound->snd_sound)
 219                                 sound->snd_sound = AUD_limitSound(sound->child_sound, sound->start, sound->end);
 220                         break;
 221                 }
 222
 223                 if(sound->cache)
 224                 {
 225
 226                 }
 227         }
 228 }
 229
 230 void sound_free(struct bSound* sound)
 231 {
 232         if (sound->packedfile)
 233         {
 234                 freePackedFile(sound->packedfile);
 235                 sound->packedfile = NULL;
 236         }
 237
 238         if(sound->snd_sound)
 239         {
 240                 AUD_unload(sound->snd_sound);
 241                 sound->snd_sound = NULL;
 242         }
 243 }
 244
 245 void sound_unlink(struct bContext *C, struct bSound* sound)
 246 {
 247         bSound *snd;
 248         Scene *scene;
 249         SoundHandle *handle;
 250
 251         for(snd = CTX_data_main(C)->sound.first; snd; snd = snd->id.next)
 252         {
 253                 if(snd->child_sound == sound)
 254                 {
 255                         snd->child_sound = NULL;
 256                         if(snd->snd_sound)
 257                         {
 258                                 AUD_unload(sound->snd_sound);
 259                                 snd->snd_sound = NULL;
 260                         }
 261
 262                         sound_unlink(C, snd);
 263                 }
 264         }
 265
 266         for(scene = CTX_data_main(C)->scene.first; scene; scene = scene->id.next)
 267         {
 268                 for(handle = scene->sound_handles.first; handle; handle = handle->next)
 269                 {
 270                         if(handle->source == sound)
 271                         {
 272                                 handle->source = NULL;
 273                                 if(handle->handle)
 274                                         AUD_stop(handle->handle);
 275                         }
 276                 }
 277         }
 278 }
 279
 280 struct SoundHandle* sound_new_handle(struct Scene *scene, struct bSound* sound, int startframe, int endframe, int frameskip)
 281 {
 282         ListBase* handles = &scene->sound_handles;
 283
 284         SoundHandle* handle = MEM_callocN(sizeof(SoundHandle), "sound_handle");
 285         handle->source = sound;
 286         handle->startframe = startframe;
 287         handle->endframe = endframe;
 288         handle->frameskip = frameskip;
 289         handle->state = AUD_STATUS_INVALID;
 290         handle->volume = 1.0f;
 291
 292         BLI_addtail(handles, handle);
 293
 294         return handle;
 295 }
 296
 297 void sound_delete_handle(struct Scene *scene, struct SoundHandle *handle)
 298 {
 299         if(handle == NULL)
 300                 return;
 301
 302         if(handle->handle)
 303                 AUD_stop(handle->handle);
 304
 305         BLI_freelinkN(&scene->sound_handles, handle);
 306 }
 307
 308 void sound_stop_all(struct bContext *C)
 309 {
 310         SoundHandle *handle;
 311
 312         for(handle = CTX_data_scene(C)->sound_handles.first; handle; handle = handle->next)
 313         {
 314                 if(handle->state == AUD_STATUS_PLAYING)
 315                 {
 316                         AUD_pause(handle->handle);
 317                         handle->state = AUD_STATUS_PAUSED;
 318                 }
 319         }
 320 }
 321
 322 #define SOUND_PLAYBACK_LAMBDA 1.0
 323
 324 void sound_update_playing(struct bContext *C)
 325 {
 326         SoundHandle *handle;
 327         Scene* scene = CTX_data_scene(C);
 328         int cfra = CFRA;
 329         float fps = FPS;
 330         int action;
 331
 332         AUD_lock();
 333
 334         for(handle = scene->sound_handles.first; handle; handle = handle->next)
 335         {
 336                 if(cfra < handle->startframe || cfra >= handle->endframe || handle->mute)
 337                 {
 338                         if(handle->state == AUD_STATUS_PLAYING)
 339                         {
 340                                 AUD_pause(handle->handle);
 341                                 handle->state = AUD_STATUS_PAUSED;
 342                         }
 343                 }
 344                 else
 345                 {
 346                         action = 0;
 347
 348                         if(handle->changed != handle->source->changed)
 349                         {
 350                                 handle->changed = handle->source->changed;
 351                                 action = 3;
 352                                 if(handle->state != AUD_STATUS_INVALID)
 353                                 {
 354                                         AUD_stop(handle->handle);
 355                                         handle->state = AUD_STATUS_INVALID;
 356                                 }
 357                         }
 358                         else
 359                         {
 360                                 if(handle->state != AUD_STATUS_PLAYING)
 361                                         action = 3;
 362                                 else
 363                                 {
 364                                         handle->state = AUD_getStatus(handle->handle);
 365                                         if(handle->state != AUD_STATUS_PLAYING)
 366                                                 action = 3;
 367                                         else
 368                                         {
 369                                                 float diff = AUD_getPosition(handle->handle) - (cfra - handle->startframe) / fps;
 370 // AUD_XXX                                              float diff = AUD_getPosition(handle->handle) * fps - cfra + handle->startframe
 371                                                 if(diff < 0.0)
 372                                                         diff = -diff;
 373                                                 if(diff > SOUND_PLAYBACK_LAMBDA)
 374 // AUD_XXX                                              if(diff > 5.0f)
 375                                                 {
 376                                                         action = 2;
 377                                                 }
 378                                         }
 379                                 }
 380                         }
 381
 382                         if(action & 1)
 383                         {
 384                                 if(handle->state == AUD_STATUS_INVALID)
 385                                 {
 386                                         if(handle->source && handle->source->snd_sound)
 387                                         {
 388                                                 AUD_Sound* limiter = AUD_limitSound(handle->source->cache ? handle->source->cache : handle->source->snd_sound, handle->frameskip / fps, (handle->frameskip + handle->endframe - handle->startframe)/fps);
 389                                                 handle->handle = AUD_play(limiter, 1);
 390                                                 AUD_unload(limiter);
 391                                                 if(handle->handle)
 392                                                         handle->state = AUD_STATUS_PLAYING;
 393                                                 if(cfra == handle->startframe)
 394                                                         action &= ~2;
 395                                         }
 396                                 }
 397                                 else
 398                                         if(AUD_resume(handle->handle))
 399                                                 handle->state = AUD_STATUS_PLAYING;
 400                                         else
 401                                                 handle->state = AUD_STATUS_INVALID;
 402                         }
 403
 404                         if(action & 2)
 405                                 AUD_seek(handle->handle, (cfra - handle->startframe) / fps);
 406                 }
 407         }
 408
 409         AUD_unlock();
 410 }
 411
 412 void sound_scrub(struct bContext *C)
 413 {
 414         SoundHandle *handle;
 415         Scene* scene = CTX_data_scene(C);
 416         int cfra = CFRA;
 417         float fps = FPS;
 418
 419         if(scene->r.audio.flag & AUDIO_SCRUB && !CTX_wm_screen(C)->animtimer)
 420         {
 421                 AUD_lock();
 422
 423                 for(handle = scene->sound_handles.first; handle; handle = handle->next)
 424                 {
 425                         if(cfra >= handle->startframe && cfra < handle->endframe && !handle->mute)
 426                         {
 427                                 if(handle->source && handle->source->snd_sound)
 428                                 {
 429                                         int frameskip = handle->frameskip + cfra - handle->startframe;
 430                                         AUD_Sound* limiter = AUD_limitSound(handle->source->cache ? handle->source->cache : handle->source->snd_sound, frameskip / fps, (frameskip + 1)/fps);
 431                                         AUD_play(limiter, 0);
 432                                         AUD_unload(limiter);
 433                                 }
 434                         }
 435                 }
 436
 437                 AUD_unlock();
 438         }
 439 }
 440
 441 AUD_Device* sound_mixdown(struct Scene *scene, AUD_Specs specs, int start, int end)
 442 {
 443         AUD_Device* mixdown = AUD_openReadDevice(specs);
 444         SoundHandle *handle;
 445         float fps = FPS;
 446         AUD_Sound *limiter, *delayer;
 447         int frameskip, s, e;
 448
 449         end++;
 450
 451         for(handle = scene->sound_handles.first; handle; handle = handle->next)
 452         {
 453                 if(start < handle->endframe && end > handle->startframe && !handle->mute && handle->source && handle->source->snd_sound)
 454                 {
 455                         frameskip = handle->frameskip;
 456                         s = handle->startframe - start;
 457                         e = handle->frameskip + AUD_MIN(handle->endframe, end) - handle->startframe;
 458
 459                         if(s < 0)
 460                         {
 461                                 frameskip -= s;
 462                                 s = 0;
 463                         }
 464
 465                         limiter = AUD_limitSound(handle->source->snd_sound, frameskip / fps, e / fps);
 466                         delayer = AUD_delaySound(limiter, s / fps);
 467
 468                         AUD_playDevice(mixdown, delayer);
 469
 470                         AUD_unload(delayer);
 471                         AUD_unload(limiter);
 472                 }
 473         }
 474
 475         return mixdown;
 476 }