source/blender/editors/sound/sound_ops.c

   1 /*
   2  * ***** BEGIN GPL LICENSE BLOCK *****
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software Foundation,
  16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  *
  18  * The Original Code is Copyright (C) 2007 Blender Foundation.
  19  * All rights reserved.
  20  *
  21  *
  22  * Contributor(s): Blender Foundation
  23  *
  24  * ***** END GPL LICENSE BLOCK *****
  25  */
  26
  27 /** \file blender/editors/sound/sound_ops.c
  28  *  \ingroup edsnd
  29  */
  30
  31
  32 #include <string.h>
  33 #include <stdlib.h>
  34 #include <stdio.h>
  35 #include <stddef.h>
  36
  37 #include "MEM_guardedalloc.h"
  38
  39 #include "BLI_blenlib.h"
  40 #include "BLI_utildefines.h"
  41
  42 #include "DNA_anim_types.h"
  43 #include "DNA_packedFile_types.h"
  44 #include "DNA_scene_types.h"
  45 #include "DNA_space_types.h"
  46 #include "DNA_sequence_types.h"
  47 #include "DNA_sound_types.h"
  48 #include "DNA_userdef_types.h"
  49
  50 #include "BKE_context.h"
  51 #include "BKE_fcurve.h"
  52 #include "BKE_global.h"
  53 #include "BKE_main.h"
  54 #include "BKE_report.h"
  55 #include "BKE_packedFile.h"
  56 #include "BKE_scene.h"
  57 #include "BKE_sound.h"
  58 #include "BKE_sequencer.h"
  59
  60 #include "RNA_access.h"
  61 #include "RNA_define.h"
  62 #include "RNA_enum_types.h"
  63
  64 #include "UI_interface.h"
  65
  66 #include "WM_api.h"
  67 #include "WM_types.h"
  68
  69 #ifdef WITH_AUDASPACE
  70 #  include "AUD_C-API.h"
  71 #endif
  72
  73 #include "ED_sound.h"
  74 #include "ED_util.h"
  75
  76 #include "sound_intern.h"
  77
  78 /******************** open sound operator ********************/
  79
  80 static int sound_open_cancel(bContext *UNUSED(C), wmOperator *op)
  81 {
  82         MEM_freeN(op->customdata);
  83         op->customdata= NULL;
  84         return OPERATOR_CANCELLED;
  85 }
  86
  87 static void sound_open_init(bContext *C, wmOperator *op)
  88 {
  89         PropertyPointerRNA *pprop;
  90
  91         op->customdata= pprop= MEM_callocN(sizeof(PropertyPointerRNA), "OpenPropertyPointerRNA");
  92         uiIDContextProperty(C, &pprop->ptr, &pprop->prop);
  93 }
  94
  95 #ifdef WITH_AUDASPACE
  96 static int sound_open_exec(bContext *C, wmOperator *op)
  97 {
  98         char path[FILE_MAX];
  99         bSound *sound;
 100         PropertyPointerRNA *pprop;
 101         PointerRNA idptr;
 102         AUD_SoundInfo info;
 103         Main *bmain = CTX_data_main(C);
 104
 105         RNA_string_get(op->ptr, "filepath", path);
 106         sound = sound_new_file(bmain, path);
 107
 108         if(!op->customdata)
 109                 sound_open_init(C, op);
 110
 111         if (sound==NULL || sound->playback_handle == NULL) {
 112                 if(op->customdata) MEM_freeN(op->customdata);
 113                 BKE_report(op->reports, RPT_ERROR, "Unsupported audio format");
 114                 return OPERATOR_CANCELLED;
 115         }
 116
 117         info = AUD_getInfo(sound->playback_handle);
 118
 119         if (info.specs.channels == AUD_CHANNELS_INVALID) {
 120                 sound_delete(bmain, sound);
 121                 if(op->customdata) MEM_freeN(op->customdata);
 122                 BKE_report(op->reports, RPT_ERROR, "Unsupported audio format");
 123                 return OPERATOR_CANCELLED;
 124         }
 125
 126         if(RNA_boolean_get(op->ptr, "mono")) {
 127                 sound->flags |= SOUND_FLAGS_MONO;
 128                 sound_load(bmain, sound);
 129         }
 130
 131         if (RNA_boolean_get(op->ptr, "cache")) {
 132                 sound_cache(sound);
 133         }
 134
 135         /* hook into UI */
 136         pprop= op->customdata;
 137
 138         if(pprop->prop) {
 139                 /* when creating new ID blocks, use is already 1, but RNA
 140                  * pointer se also increases user, so this compensates it */
 141                 sound->id.us--;
 142
 143                 RNA_id_pointer_create(&sound->id, &idptr);
 144                 RNA_property_pointer_set(&pprop->ptr, pprop->prop, idptr);
 145                 RNA_property_update(C, &pprop->ptr, pprop->prop);
 146         }
 147
 148         if(op->customdata) MEM_freeN(op->customdata);
 149         return OPERATOR_FINISHED;
 150 }
 151
 152 #else //WITH_AUDASPACE
 153
 154 static int sound_open_exec(bContext *UNUSED(C), wmOperator *op)
 155 {
 156         BKE_report(op->reports, RPT_ERROR, "Compiled without sound support");
 157
 158         return OPERATOR_CANCELLED;
 159 }
 160
 161 #endif
 162
 163 static int sound_open_invoke(bContext *C, wmOperator *op, wmEvent *event)
 164 {
 165         if(RNA_struct_property_is_set(op->ptr, "filepath"))
 166                 return sound_open_exec(C, op);
 167
 168         sound_open_init(C, op);
 169
 170         return WM_operator_filesel(C, op, event);
 171 }
 172
 173 static void SOUND_OT_open(wmOperatorType *ot)
 174 {
 175         /* identifiers */
 176         ot->name= "Open Sound";
 177         ot->description= "Load a sound file";
 178         ot->idname= "SOUND_OT_open";
 179
 180         /* api callbacks */
 181         ot->exec= sound_open_exec;
 182         ot->invoke= sound_open_invoke;
 183         ot->cancel= sound_open_cancel;
 184
 185         /* flags */
 186         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 187
 188         /* properties */
 189         WM_operator_properties_filesel(ot, FOLDERFILE|SOUNDFILE|MOVIEFILE, FILE_SPECIAL, FILE_OPENFILE, WM_FILESEL_FILEPATH | WM_FILESEL_RELPATH);
 190         RNA_def_boolean(ot->srna, "cache", FALSE, "Cache", "Cache the sound in memory");
 191         RNA_def_boolean(ot->srna, "mono", FALSE, "Mono", "Mixdown the sound to mono");
 192 }
 193
 194 static void SOUND_OT_open_mono(wmOperatorType *ot)
 195 {
 196         /* identifiers */
 197         ot->name= "Open Sound Mono";
 198         ot->description= "Load a sound file as mono";
 199         ot->idname= "SOUND_OT_open_mono";
 200
 201         /* api callbacks */
 202         ot->exec= sound_open_exec;
 203         ot->invoke= sound_open_invoke;
 204         ot->cancel= sound_open_cancel;
 205
 206         /* flags */
 207         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 208
 209         /* properties */
 210         WM_operator_properties_filesel(ot, FOLDERFILE|SOUNDFILE|MOVIEFILE, FILE_SPECIAL, FILE_OPENFILE, WM_FILESEL_FILEPATH | WM_FILESEL_RELPATH);
 211         RNA_def_boolean(ot->srna, "cache", FALSE, "Cache", "Cache the sound in memory");
 212         RNA_def_boolean(ot->srna, "mono", TRUE, "Mono", "Mixdown the sound to mono");
 213 }
 214
 215 /* ******************************************************* */
 216
 217 static int sound_update_animation_flags_exec(bContext *C, wmOperator *UNUSED(op))
 218 {
 219         Sequence* seq;
 220         Scene* scene = CTX_data_scene(C);
 221         struct FCurve* fcu;
 222         char driven;
 223
 224         SEQ_BEGIN(scene->ed, seq) {
 225                 fcu = id_data_find_fcurve(&scene->id, seq, &RNA_Sequence, "volume", 0, &driven);
 226                 if(fcu || driven)
 227                         seq->flag |= SEQ_AUDIO_VOLUME_ANIMATED;
 228                 else
 229                         seq->flag &= ~SEQ_AUDIO_VOLUME_ANIMATED;
 230
 231                 fcu = id_data_find_fcurve(&scene->id, seq, &RNA_Sequence, "pitch", 0, &driven);
 232                 if(fcu || driven)
 233                         seq->flag |= SEQ_AUDIO_PITCH_ANIMATED;
 234                 else
 235                         seq->flag &= ~SEQ_AUDIO_PITCH_ANIMATED;
 236
 237                 fcu = id_data_find_fcurve(&scene->id, seq, &RNA_Sequence, "pan", 0, &driven);
 238                 if(fcu || driven)
 239                         seq->flag |= SEQ_AUDIO_PAN_ANIMATED;
 240                 else
 241                         seq->flag &= ~SEQ_AUDIO_PAN_ANIMATED;
 242         }
 243         SEQ_END
 244
 245         fcu = id_data_find_fcurve(&scene->id, scene, &RNA_Scene, "audio_volume", 0, &driven);
 246         if(fcu || driven)
 247                 scene->audio.flag |= AUDIO_VOLUME_ANIMATED;
 248         else
 249                 scene->audio.flag &= ~AUDIO_VOLUME_ANIMATED;
 250
 251         return OPERATOR_FINISHED;
 252 }
 253
 254 static void SOUND_OT_update_animation_flags(wmOperatorType *ot)
 255 {
 256         /*
 257           This operator is needed to set a correct state of the sound animation
 258           System. Unfortunately there's no really correct place to call the exec
 259           function, that's why I made it an operator that's only visible in the
 260           search menu. Apart from that the bake animation operator calls it too.
 261         */
 262
 263         /* identifiers */
 264         ot->name= "Update animation";
 265         ot->description= "Update animation flags";
 266         ot->idname= "SOUND_OT_update_animation_flags";
 267
 268         /* api callbacks */
 269         ot->exec= sound_update_animation_flags_exec;
 270
 271         /* flags */
 272         ot->flag= OPTYPE_REGISTER;
 273 }
 274
 275 /* ******************************************************* */
 276
 277 static int sound_bake_animation_exec(bContext *C, wmOperator *UNUSED(op))
 278 {
 279         Main* bmain = CTX_data_main(C);
 280         Scene* scene = CTX_data_scene(C);
 281         int oldfra = scene->r.cfra;
 282         int cfra;
 283
 284         sound_update_animation_flags_exec(C, NULL);
 285
 286         for(cfra = scene->r.sfra > 0 ? scene->r.sfra - 1 : 0; cfra <= scene->r.efra + 1; cfra++)
 287         {
 288                 scene->r.cfra = cfra;
 289                 scene_update_for_newframe(bmain, scene, scene->lay);
 290         }
 291
 292         scene->r.cfra = oldfra;
 293         scene_update_for_newframe(bmain, scene, scene->lay);
 294
 295         return OPERATOR_FINISHED;
 296 }
 297
 298 static void SOUND_OT_bake_animation(wmOperatorType *ot)
 299 {
 300         /* identifiers */
 301         ot->name= "Update animation cache";
 302         ot->description= "Updates the audio animation cache so that it's up to date";
 303         ot->idname= "SOUND_OT_bake_animation";
 304
 305         /* api callbacks */
 306         ot->exec= sound_bake_animation_exec;
 307
 308         /* flags */
 309         ot->flag= OPTYPE_REGISTER;
 310 }
 311
 312
 313 /******************** mixdown operator ********************/
 314
 315 static int sound_mixdown_exec(bContext *C, wmOperator *op)
 316 {
 317 #ifdef WITH_AUDASPACE
 318         char path[FILE_MAX];
 319         char filename[FILE_MAX];
 320         Scene *scene;
 321         Main *bmain;
 322
 323         int bitrate, accuracy;
 324         AUD_DeviceSpecs specs;
 325         AUD_Container container;
 326         AUD_Codec codec;
 327         const char* result;
 328
 329         sound_bake_animation_exec(C, op);
 330
 331         RNA_string_get(op->ptr, "filepath", path);
 332         bitrate = RNA_int_get(op->ptr, "bitrate") * 1000;
 333         accuracy = RNA_int_get(op->ptr, "accuracy");
 334         specs.format = RNA_enum_get(op->ptr, "format");
 335         container = RNA_enum_get(op->ptr, "container");
 336         codec = RNA_enum_get(op->ptr, "codec");
 337         scene = CTX_data_scene(C);
 338         bmain = CTX_data_main(C);
 339         specs.channels = scene->r.ffcodecdata.audio_channels;
 340         specs.rate = scene->r.ffcodecdata.audio_mixrate;
 341
 342         BLI_strncpy(filename, path, sizeof(filename));
 343         BLI_path_abs(filename, bmain->name);
 344
 345         result = AUD_mixdown(scene->sound_scene, SFRA * specs.rate / FPS, (EFRA - SFRA) * specs.rate / FPS,
 346                                                  accuracy, filename, specs, container, codec, bitrate);
 347
 348         if(result)
 349         {
 350                 BKE_report(op->reports, RPT_ERROR, result);
 351                 return OPERATOR_CANCELLED;
 352         }
 353 #else // WITH_AUDASPACE
 354         (void)C;
 355         (void)op;
 356 #endif // WITH_AUDASPACE
 357         return OPERATOR_FINISHED;
 358 }
 359
 360 static int sound_mixdown_invoke(bContext *C, wmOperator *op, wmEvent *event)
 361 {
 362         if(RNA_struct_property_is_set(op->ptr, "filepath"))
 363                 return sound_mixdown_exec(C, op);
 364
 365         return WM_operator_filesel(C, op, event);
 366 }
 367
 368 #ifdef WITH_AUDASPACE
 369
 370 static int sound_mixdown_draw_check_prop(PointerRNA *UNUSED(ptr), PropertyRNA *prop)
 371 {
 372         const char *prop_id= RNA_property_identifier(prop);
 373         return !(       strcmp(prop_id, "filepath") == 0 ||
 374                                 strcmp(prop_id, "directory") == 0 ||
 375                                 strcmp(prop_id, "filename") == 0
 376         );
 377 }
 378
 379 static void sound_mixdown_draw(bContext *C, wmOperator *op)
 380 {
 381         static EnumPropertyItem pcm_format_items[] = {
 382                 {AUD_FORMAT_U8, "U8", 0, "U8", "8 bit unsigned"},
 383                 {AUD_FORMAT_S16, "S16", 0, "S16", "16 bit signed"},
 384 #ifdef WITH_SNDFILE
 385                 {AUD_FORMAT_S24, "S24", 0, "S24", "24 bit signed"},
 386 #endif
 387                 {AUD_FORMAT_S32, "S32", 0, "S32", "32 bit signed"},
 388                 {AUD_FORMAT_FLOAT32, "F32", 0, "F32", "32 bit floating point"},
 389                 {AUD_FORMAT_FLOAT64, "F64", 0, "F64", "64 bit floating point"},
 390                 {0, NULL, 0, NULL, NULL}};
 391
 392         static EnumPropertyItem mp3_format_items[] = {
 393                 {AUD_FORMAT_S16, "S16", 0, "S16", "16 bit signed"},
 394                 {AUD_FORMAT_S32, "S32", 0, "S32", "32 bit signed"},
 395                 {0, NULL, 0, NULL, NULL}};
 396
 397         static EnumPropertyItem ac3_format_items[] = {
 398                 {AUD_FORMAT_S16, "S16", 0, "S16", "16 bit signed"},
 399                 {AUD_FORMAT_FLOAT32, "F32", 0, "F32", "32 bit floating point"},
 400                 {0, NULL, 0, NULL, NULL}};
 401
 402 #ifdef WITH_SNDFILE
 403         static EnumPropertyItem flac_format_items[] = {
 404                 {AUD_FORMAT_S16, "S16", 0, "S16", "16 bit signed"},
 405                 {AUD_FORMAT_S24, "S24", 0, "S24", "24 bit signed"},
 406                 {0, NULL, 0, NULL, NULL}};
 407 #endif
 408
 409         static EnumPropertyItem all_codec_items[] = {
 410                 {AUD_CODEC_AAC, "AAC", 0, "AAC", "Advanced Audio Coding"},
 411                 {AUD_CODEC_AC3, "AC3", 0, "AC3", "Dolby Digital ATRAC 3"},
 412                 {AUD_CODEC_FLAC, "FLAC", 0, "FLAC", "Free Lossless Audio Codec"},
 413                 {AUD_CODEC_MP2, "MP2", 0, "MP2", "MPEG-1 Audio Layer II"},
 414                 {AUD_CODEC_MP3, "MP3", 0, "MP3", "MPEG-2 Audio Layer III"},
 415                 {AUD_CODEC_PCM, "PCM", 0, "PCM", "Pulse Code Modulation (RAW)"},
 416                 {AUD_CODEC_VORBIS, "VORBIS", 0, "Vorbis", "Xiph.Org Vorbis Codec"},
 417                 {0, NULL, 0, NULL, NULL}};
 418
 419         static EnumPropertyItem ogg_codec_items[] = {
 420                 {AUD_CODEC_FLAC, "FLAC", 0, "FLAC", "Free Lossless Audio Codec"},
 421                 {AUD_CODEC_VORBIS, "VORBIS", 0, "Vorbis", "Xiph.Org Vorbis Codec"},
 422                 {0, NULL, 0, NULL, NULL}};
 423
 424         uiLayout *layout = op->layout;
 425         wmWindowManager *wm= CTX_wm_manager(C);
 426         PointerRNA ptr;
 427         PropertyRNA *prop_format;
 428         PropertyRNA *prop_codec;
 429         PropertyRNA *prop_bitrate;
 430
 431         AUD_Container container = RNA_enum_get(op->ptr, "container");
 432         AUD_Codec codec = RNA_enum_get(op->ptr, "codec");
 433
 434         prop_format = RNA_struct_find_property(op->ptr, "format");
 435         prop_codec = RNA_struct_find_property(op->ptr, "codec");
 436         prop_bitrate = RNA_struct_find_property(op->ptr, "bitrate");
 437
 438         RNA_def_property_clear_flag(prop_bitrate, PROP_HIDDEN);
 439         RNA_def_property_flag(prop_codec, PROP_HIDDEN);
 440         RNA_def_property_flag(prop_format, PROP_HIDDEN);
 441
 442         switch(container)
 443         {
 444         case AUD_CONTAINER_AC3:
 445                 RNA_def_property_clear_flag(prop_format, PROP_HIDDEN);
 446                 RNA_def_property_enum_items(prop_format, ac3_format_items);
 447                 RNA_def_property_enum_items(prop_codec, all_codec_items);
 448                 RNA_enum_set(op->ptr, "codec", AUD_CODEC_AC3);
 449                 break;
 450         case AUD_CONTAINER_FLAC:
 451                 RNA_def_property_flag(prop_bitrate, PROP_HIDDEN);
 452                 RNA_def_property_enum_items(prop_codec, all_codec_items);
 453                 RNA_enum_set(op->ptr, "codec", AUD_CODEC_FLAC);
 454 #ifdef WITH_SNDFILE
 455                 RNA_def_property_clear_flag(prop_format, PROP_HIDDEN);
 456                 RNA_def_property_enum_items(prop_format, flac_format_items);
 457 #else
 458                 RNA_enum_set(op->ptr, "format", AUD_FORMAT_S16);
 459 #endif
 460                 break;
 461         case AUD_CONTAINER_MATROSKA:
 462                 RNA_def_property_clear_flag(prop_codec, PROP_HIDDEN);
 463                 RNA_def_property_enum_items(prop_codec, all_codec_items);
 464
 465                 switch(codec)
 466                 {
 467                 case AUD_CODEC_AAC:
 468                         RNA_enum_set(op->ptr, "format", AUD_FORMAT_S16);
 469                         break;
 470                 case AUD_CODEC_AC3:
 471                         RNA_def_property_enum_items(prop_format, ac3_format_items);
 472                         RNA_def_property_clear_flag(prop_format, PROP_HIDDEN);
 473                         break;
 474                 case AUD_CODEC_FLAC:
 475                         RNA_def_property_flag(prop_bitrate, PROP_HIDDEN);
 476                         RNA_enum_set(op->ptr, "format", AUD_FORMAT_S16);
 477                         break;
 478                 case AUD_CODEC_MP2:
 479                         RNA_enum_set(op->ptr, "format", AUD_FORMAT_S16);
 480                         break;
 481                 case AUD_CODEC_MP3:
 482                         RNA_def_property_enum_items(prop_format, mp3_format_items);
 483                         RNA_def_property_clear_flag(prop_format, PROP_HIDDEN);
 484                         break;
 485                 case AUD_CODEC_PCM:
 486                         RNA_def_property_flag(prop_bitrate, PROP_HIDDEN);
 487                         RNA_def_property_enum_items(prop_format, pcm_format_items);
 488                         RNA_def_property_clear_flag(prop_format, PROP_HIDDEN);
 489                         break;
 490                 case AUD_CODEC_VORBIS:
 491                         RNA_enum_set(op->ptr, "format", AUD_FORMAT_S16);
 492                         break;
 493                 default:
 494                         break;
 495                 }
 496
 497                 break;
 498         case AUD_CONTAINER_MP2:
 499                 RNA_enum_set(op->ptr, "format", AUD_FORMAT_S16);
 500                 RNA_enum_set(op->ptr, "codec", AUD_CODEC_MP2);
 501                 RNA_def_property_enum_items(prop_codec, all_codec_items);
 502                 break;
 503         case AUD_CONTAINER_MP3:
 504                 RNA_def_property_clear_flag(prop_format, PROP_HIDDEN);
 505                 RNA_def_property_enum_items(prop_format, mp3_format_items);
 506                 RNA_def_property_enum_items(prop_codec, all_codec_items);
 507                 RNA_enum_set(op->ptr, "codec", AUD_CODEC_MP3);
 508                 break;
 509         case AUD_CONTAINER_OGG:
 510                 RNA_def_property_clear_flag(prop_codec, PROP_HIDDEN);
 511                 RNA_def_property_enum_items(prop_codec, ogg_codec_items);
 512                 RNA_enum_set(op->ptr, "format", AUD_FORMAT_S16);
 513                 break;
 514         case AUD_CONTAINER_WAV:
 515                 RNA_def_property_flag(prop_bitrate, PROP_HIDDEN);
 516                 RNA_def_property_clear_flag(prop_format, PROP_HIDDEN);
 517                 RNA_def_property_enum_items(prop_format, pcm_format_items);
 518                 RNA_def_property_enum_items(prop_codec, all_codec_items);
 519                 RNA_enum_set(op->ptr, "codec", AUD_CODEC_PCM);
 520                 break;
 521         default:
 522                 break;
 523         }
 524
 525         RNA_pointer_create(&wm->id, op->type->srna, op->properties, &ptr);
 526
 527         /* main draw call */
 528         uiDefAutoButsRNA(layout, &ptr, sound_mixdown_draw_check_prop, '\0');
 529 }
 530 #endif // WITH_AUDASPACE
 531
 532 static void SOUND_OT_mixdown(wmOperatorType *ot)
 533 {
 534 #ifdef WITH_AUDASPACE
 535         static EnumPropertyItem format_items[] = {
 536                 {AUD_FORMAT_U8, "U8", 0, "U8", "8 bit unsigned"},
 537                 {AUD_FORMAT_S16, "S16", 0, "S16", "16 bit signed"},
 538                 {AUD_FORMAT_S24, "S24", 0, "S24", "24 bit signed"},
 539                 {AUD_FORMAT_S32, "S32", 0, "S32", "32 bit signed"},
 540                 {AUD_FORMAT_FLOAT32, "F32", 0, "F32", "32 bit floating point"},
 541                 {AUD_FORMAT_FLOAT64, "F64", 0, "F64", "64 bit floating point"},
 542                 {0, NULL, 0, NULL, NULL}};
 543
 544         static EnumPropertyItem container_items[] = {
 545 #ifdef WITH_FFMPEG
 546                 {AUD_CONTAINER_AC3, "AC3", 0, "ac3", "Dolby Digital ATRAC 3"},
 547 #endif
 548                 {AUD_CONTAINER_FLAC, "FLAC", 0, "flac", "Free Lossless Audio Codec"},
 549 #ifdef WITH_FFMPEG
 550                 {AUD_CONTAINER_MATROSKA, "MATROSKA", 0, "mkv", "Matroska"},
 551                 {AUD_CONTAINER_MP2, "MP2", 0, "mp2", "MPEG-1 Audio Layer II"},
 552                 {AUD_CONTAINER_MP3, "MP3", 0, "mp3", "MPEG-2 Audio Layer III"},
 553 #endif
 554                 {AUD_CONTAINER_OGG, "OGG", 0, "ogg", "Xiph.Org Ogg Container"},
 555                 {AUD_CONTAINER_WAV, "WAV", 0, "wav", "Waveform Audio File Format"},
 556                 {0, NULL, 0, NULL, NULL}};
 557
 558         static EnumPropertyItem codec_items[] = {
 559 #ifdef WITH_FFMPEG
 560                 {AUD_CODEC_AAC, "AAC", 0, "AAC", "Advanced Audio Coding"},
 561                 {AUD_CODEC_AC3, "AC3", 0, "AC3", "Dolby Digital ATRAC 3"},
 562 #endif
 563                 {AUD_CODEC_FLAC, "FLAC", 0, "FLAC", "Free Lossless Audio Codec"},
 564 #ifdef WITH_FFMPEG
 565                 {AUD_CODEC_MP2, "MP2", 0, "MP2", "MPEG-1 Audio Layer II"},
 566                 {AUD_CODEC_MP3, "MP3", 0, "MP3", "MPEG-2 Audio Layer III"},
 567 #endif
 568                 {AUD_CODEC_PCM, "PCM", 0, "PCM", "Pulse Code Modulation (RAW)"},
 569                 {AUD_CODEC_VORBIS, "VORBIS", 0, "Vorbis", "Xiph.Org Vorbis Codec"},
 570                 {0, NULL, 0, NULL, NULL}};
 571
 572 #endif // WITH_AUDASPACE
 573
 574         /* identifiers */
 575         ot->name= "Mixdown";
 576         ot->description= "Mixes the scene's audio to a sound file";
 577         ot->idname= "SOUND_OT_mixdown";
 578
 579         /* api callbacks */
 580         ot->exec= sound_mixdown_exec;
 581         ot->invoke= sound_mixdown_invoke;
 582
 583 #ifdef WITH_AUDASPACE
 584         ot->ui= sound_mixdown_draw;
 585 #endif
 586         /* flags */
 587         ot->flag= OPTYPE_REGISTER;
 588
 589         /* properties */
 590         WM_operator_properties_filesel(ot, FOLDERFILE|SOUNDFILE, FILE_SPECIAL, FILE_SAVE, WM_FILESEL_FILEPATH);
 591 #ifdef WITH_AUDASPACE
 592         RNA_def_int(ot->srna, "accuracy", 1024, 1, 16777216, "Accuracy", "Sample accuracy, important for animation data (the lower the value, the more accurate)", 1, 16777216);
 593         RNA_def_enum(ot->srna, "container", container_items, AUD_CONTAINER_FLAC, "Container", "File format");
 594         RNA_def_enum(ot->srna, "codec", codec_items, AUD_CODEC_FLAC, "Codec", "Audio Codec");
 595         RNA_def_enum(ot->srna, "format", format_items, AUD_FORMAT_S16, "Format", "Sample format");
 596         RNA_def_int(ot->srna, "bitrate", 192, 32, 512, "Bitrate", "Bitrate in kbit/s", 32, 512);
 597 #endif // WITH_AUDASPACE
 598 }
 599
 600 /* ******************************************************* */
 601
 602 static int sound_poll(bContext *C)
 603 {
 604         Editing* ed = CTX_data_scene(C)->ed;
 605
 606         if(!ed || !ed->act_seq || ed->act_seq->type != SEQ_SOUND)
 607                 return 0;
 608
 609         return 1;
 610 }
 611 /********************* pack operator *********************/
 612
 613 static int sound_pack_exec(bContext *C, wmOperator *op)
 614 {
 615         Main *bmain= CTX_data_main(C);
 616         Editing* ed = CTX_data_scene(C)->ed;
 617         bSound* sound;
 618
 619         if(!ed || !ed->act_seq || ed->act_seq->type != SEQ_SOUND)
 620                 return OPERATOR_CANCELLED;
 621
 622         sound = ed->act_seq->sound;
 623
 624         if(!sound || sound->packedfile)
 625                 return OPERATOR_CANCELLED;
 626
 627         sound->packedfile= newPackedFile(op->reports, sound->name, ID_BLEND_PATH(bmain, &sound->id));
 628         sound_load(CTX_data_main(C), sound);
 629
 630         return OPERATOR_FINISHED;
 631 }
 632
 633 static void SOUND_OT_pack(wmOperatorType *ot)
 634 {
 635         /* identifiers */
 636         ot->name= "Pack Sound";
 637         ot->description= "Pack the sound into the current blend file";
 638         ot->idname= "SOUND_OT_pack";
 639
 640         /* api callbacks */
 641         ot->exec= sound_pack_exec;
 642         ot->poll= sound_poll;
 643
 644         /* flags */
 645         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 646 }
 647
 648 /********************* unpack operator *********************/
 649
 650 static int sound_unpack_exec(bContext *C, wmOperator *op)
 651 {
 652         int method= RNA_enum_get(op->ptr, "method");
 653         bSound* sound= NULL;
 654
 655         /* find the suppplied image by name */
 656         if (RNA_struct_property_is_set(op->ptr, "id")) {
 657                 char sndname[MAX_ID_NAME-2];
 658                 RNA_string_get(op->ptr, "id", sndname);
 659                 sound = BLI_findstring(&CTX_data_main(C)->sound, sndname, offsetof(ID, name) + 2);
 660         }
 661
 662         if(!sound || !sound->packedfile)
 663                 return OPERATOR_CANCELLED;
 664
 665         if(G.fileflags & G_AUTOPACK)
 666                 BKE_report(op->reports, RPT_WARNING, "AutoPack is enabled, so image will be packed again on file save");
 667
 668         unpackSound(CTX_data_main(C), op->reports, sound, method);
 669
 670         return OPERATOR_FINISHED;
 671 }
 672
 673 static int sound_unpack_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
 674 {
 675         Editing* ed = CTX_data_scene(C)->ed;
 676         bSound* sound;
 677
 678         if(RNA_struct_property_is_set(op->ptr, "id"))
 679                 return sound_unpack_exec(C, op);
 680
 681         if(!ed || !ed->act_seq || ed->act_seq->type != SEQ_SOUND)
 682                 return OPERATOR_CANCELLED;
 683
 684         sound = ed->act_seq->sound;
 685
 686         if(!sound || !sound->packedfile)
 687                 return OPERATOR_CANCELLED;
 688
 689         if(G.fileflags & G_AUTOPACK)
 690                 BKE_report(op->reports, RPT_WARNING, "AutoPack is enabled, so image will be packed again on file save");
 691
 692         unpack_menu(C, "SOUND_OT_unpack", sound->id.name+2, sound->name, "sounds", sound->packedfile);
 693
 694         return OPERATOR_FINISHED;
 695 }
 696
 697 static void SOUND_OT_unpack(wmOperatorType *ot)
 698 {
 699         /* identifiers */
 700         ot->name= "Unpack Sound";
 701         ot->description= "Unpack the sound to the samples filename";
 702         ot->idname= "SOUND_OT_unpack";
 703
 704         /* api callbacks */
 705         ot->exec= sound_unpack_exec;
 706         ot->invoke= sound_unpack_invoke;
 707         ot->poll= sound_poll;
 708
 709         /* flags */
 710         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 711
 712         /* properties */
 713         RNA_def_enum(ot->srna, "method", unpack_method_items, PF_USE_LOCAL, "Method", "How to unpack");
 714         RNA_def_string(ot->srna, "id", "", MAX_ID_NAME-2, "Sound Name", "Sound datablock name to unpack"); /* XXX, weark!, will fail with library, name collisions */
 715 }
 716
 717 /* ******************************************************* */
 718
 719 void ED_operatortypes_sound(void)
 720 {
 721         WM_operatortype_append(SOUND_OT_open);
 722         WM_operatortype_append(SOUND_OT_open_mono);
 723         WM_operatortype_append(SOUND_OT_mixdown);
 724         WM_operatortype_append(SOUND_OT_pack);
 725         WM_operatortype_append(SOUND_OT_unpack);
 726         WM_operatortype_append(SOUND_OT_update_animation_flags);
 727         WM_operatortype_append(SOUND_OT_bake_animation);
 728 }