cinelerra/asset.C

   1 #include "asset.h"
   2 #include "defaults.h"
   3 #include "assets.h"
   4 #include "edl.h"
   5 #include "file.h"
   6 #include "filesystem.h"
   7 #include "filexml.h"
   8 #include "quicktime.h"
   9
  10
  11 #include <stdio.h>
  12 #include <string.h>
  13
  14
  15 Asset::Asset() : ListItem<Asset>()
  16 {
  17         init_values();
  18 }
  19
  20 Asset::Asset(Asset &asset) : ListItem<Asset>()
  21 {
  22         init_values();
  23         *this = asset;
  24 }
  25
  26 Asset::Asset(const char *path) : ListItem<Asset>()
  27 {
  28         init_values();
  29         strcpy(this->path, path);
  30 }
  31
  32 Asset::Asset(const int plugin_type, const char *plugin_title) : ListItem<Asset>()
  33 {
  34         init_values();
  35 }
  36
  37 Asset::~Asset()
  38 {
  39         if(index_offsets) delete [] index_offsets;
  40 // Don't delete index buffer since it is shared with the index thread.
  41 }
  42
  43
  44 int Asset::init_values()
  45 {
  46         path[0] = 0;
  47         strcpy(folder, MEDIA_FOLDER);
  48 //      format = FILE_MOV;
  49 // Has to be unknown for file probing to succeed
  50         format = FILE_UNKNOWN;
  51         channels = 0;
  52         sample_rate = 0;
  53         bits = 0;
  54         byte_order = 0;
  55         signed_ = 0;
  56         header = 0;
  57         dither = 0;
  58         audio_data = 0;
  59         video_data = 0;
  60         audio_length = 0;
  61         video_length = 0;
  62
  63         layers = 0;
  64         frame_rate = 0;
  65         width = 0;
  66         height = 0;
  67         strcpy(vcodec, QUICKTIME_YUV2);
  68         strcpy(acodec, QUICKTIME_TWOS);
  69         jpeg_quality = 100;
  70         aspect_ratio = -1;
  71
  72         ampeg_bitrate = 256;
  73         ampeg_derivative = 3;
  74
  75         vorbis_vbr = 0;
  76         vorbis_min_bitrate = -1;
  77         vorbis_bitrate = 128000;
  78         vorbis_max_bitrate = -1;
  79
  80         mp3_bitrate = 256000;
  81
  82
  83
  84
  85
  86
  87
  88 // mpeg parameters
  89         vmpeg_iframe_distance = 45;
  90         vmpeg_bframe_distance = 0;
  91         vmpeg_progressive = 0;
  92         vmpeg_denoise = 1;
  93         vmpeg_bitrate = 1000000;
  94         vmpeg_derivative = 1;
  95         vmpeg_quantization = 15;
  96         vmpeg_cmodel = 0;
  97         vmpeg_fix_bitrate = 0;
  98         vmpeg_seq_codes = 0;
  99
 100 // Divx parameters.  Defaults from encore2
 101         divx_bitrate = 2000000;
 102         divx_rc_period = 50;
 103         divx_rc_reaction_ratio = 45;
 104         divx_rc_reaction_period = 10;
 105         divx_max_key_interval = 250;
 106         divx_max_quantizer = 31;
 107         divx_min_quantizer = 1;
 108         divx_quantizer = 15;
 109         divx_quality = 5;
 110         divx_fix_bitrate = 1;
 111         divx_use_deblocking = 1;
 112
 113         ms_bitrate = 1000000;
 114         ms_bitrate_tolerance = 500000;
 115         ms_quantization = 10;
 116         ms_interlaced = 0;
 117         ms_gop_size = 45;
 118         ms_fix_bitrate = 1;
 119
 120         ac3_bitrate = 128;
 121
 122         png_use_alpha = 0;
 123         exr_use_alpha = 0;
 124         exr_compression = 0;
 125
 126         tiff_cmodel = 0;
 127         tiff_compression = 0;
 128
 129         use_header = 1;
 130
 131
 132         reset_index();
 133         id = EDL::next_id();
 134
 135         frame_start = 0;
 136
 137         return 0;
 138 }
 139
 140 int Asset::reset_index()
 141 {
 142         index_status = INDEX_NOTTESTED;
 143         index_start = old_index_end = index_end = 0;
 144         index_offsets = 0;
 145         index_zoom = 0;
 146         index_bytes = 0;
 147         index_buffer = 0;
 148         return 0;
 149 }
 150
 151 void Asset::copy_from(Asset *asset, int do_index)
 152 {
 153         copy_location(asset);
 154         copy_format(asset, do_index);
 155 }
 156
 157 void Asset::copy_location(Asset *asset)
 158 {
 159         strcpy(this->path, asset->path);
 160         strcpy(this->folder, asset->folder);
 161 }
 162
 163 void Asset::copy_format(Asset *asset, int do_index)
 164 {
 165         if(do_index) update_index(asset);
 166
 167         audio_data = asset->audio_data;
 168         format = asset->format;
 169         channels = asset->channels;
 170         sample_rate = asset->sample_rate;
 171         bits = asset->bits;
 172         byte_order = asset->byte_order;
 173         signed_ = asset->signed_;
 174         header = asset->header;
 175         dither = asset->dither;
 176         mp3_bitrate = asset->mp3_bitrate;
 177         use_header = asset->use_header;
 178         aspect_ratio = asset->aspect_ratio;
 179
 180         video_data = asset->video_data;
 181         layers = asset->layers;
 182         frame_rate = asset->frame_rate;
 183         width = asset->width;
 184         height = asset->height;
 185         strcpy(vcodec, asset->vcodec);
 186         strcpy(acodec, asset->acodec);
 187
 188         this->audio_length = asset->audio_length;
 189         this->video_length = asset->video_length;
 190
 191
 192         ampeg_bitrate = asset->ampeg_bitrate;
 193         ampeg_derivative = asset->ampeg_derivative;
 194
 195
 196         vorbis_vbr = asset->vorbis_vbr;
 197         vorbis_min_bitrate = asset->vorbis_min_bitrate;
 198         vorbis_bitrate = asset->vorbis_bitrate;
 199         vorbis_max_bitrate = asset->vorbis_max_bitrate;
 200
 201
 202
 203         jpeg_quality = asset->jpeg_quality;
 204
 205 // mpeg parameters
 206         vmpeg_iframe_distance = asset->vmpeg_iframe_distance;
 207         vmpeg_bframe_distance = asset->vmpeg_bframe_distance;
 208         vmpeg_progressive = asset->vmpeg_progressive;
 209         vmpeg_denoise = asset->vmpeg_denoise;
 210         vmpeg_bitrate = asset->vmpeg_bitrate;
 211         vmpeg_derivative = asset->vmpeg_derivative;
 212         vmpeg_quantization = asset->vmpeg_quantization;
 213         vmpeg_cmodel = asset->vmpeg_cmodel;
 214         vmpeg_fix_bitrate = asset->vmpeg_fix_bitrate;
 215         vmpeg_seq_codes = asset->vmpeg_seq_codes;
 216
 217
 218         divx_bitrate = asset->divx_bitrate;
 219         divx_rc_period = asset->divx_rc_period;
 220         divx_rc_reaction_ratio = asset->divx_rc_reaction_ratio;
 221         divx_rc_reaction_period = asset->divx_rc_reaction_period;
 222         divx_max_key_interval = asset->divx_max_key_interval;
 223         divx_max_quantizer = asset->divx_max_quantizer;
 224         divx_min_quantizer = asset->divx_min_quantizer;
 225         divx_quantizer = asset->divx_quantizer;
 226         divx_quality = asset->divx_quality;
 227         divx_fix_bitrate = asset->divx_fix_bitrate;
 228         divx_use_deblocking = asset->divx_use_deblocking;
 229
 230         ms_bitrate = asset->ms_bitrate;
 231         ms_bitrate_tolerance = asset->ms_bitrate_tolerance;
 232         ms_interlaced = asset->ms_interlaced;
 233         ms_quantization = asset->ms_quantization;
 234         ms_gop_size = asset->ms_gop_size;
 235         ms_fix_bitrate = asset->ms_fix_bitrate;
 236
 237
 238         ac3_bitrate = asset->ac3_bitrate;
 239
 240         png_use_alpha = asset->png_use_alpha;
 241         exr_use_alpha = asset->exr_use_alpha;
 242         exr_compression = asset->exr_compression;
 243
 244         tiff_cmodel = asset->tiff_cmodel;
 245         tiff_compression = asset->tiff_compression;
 246
 247         frame_start = asset->frame_start;
 248 }
 249
 250 int64_t Asset::get_index_offset(int channel)
 251 {
 252         if(channel < channels && index_offsets)
 253                 return index_offsets[channel];
 254         else
 255                 return 0;
 256 }
 257
 258 Asset& Asset::operator=(Asset &asset)
 259 {
 260         copy_location(&asset);
 261         copy_format(&asset);
 262         return *this;
 263 }
 264
 265
 266 int Asset::equivalent(Asset &asset,
 267         int test_audio,
 268         int test_video)
 269 {
 270         int result = (!strcmp(asset.path, path) &&
 271                 format == asset.format);
 272
 273         if(test_audio && result)
 274         {
 275                 result = (channels == asset.channels &&
 276                         sample_rate == asset.sample_rate &&
 277                         bits == asset.bits &&
 278                         byte_order == asset.byte_order &&
 279                         signed_ == asset.signed_ &&
 280                         header == asset.header &&
 281                         dither == asset.dither &&
 282                         !strcmp(acodec, asset.acodec));
 283         }
 284
 285
 286         if(test_video && result)
 287         {
 288                 result = (layers == asset.layers &&
 289                         frame_rate == asset.frame_rate &&
 290                         width == asset.width &&
 291                         height == asset.height &&
 292                         !strcmp(vcodec, asset.vcodec));
 293         }
 294
 295         return result;
 296 }
 297
 298 int Asset::operator==(Asset &asset)
 299 {
 300
 301         return equivalent(asset,
 302                 1,
 303                 1);
 304 }
 305
 306 int Asset::operator!=(Asset &asset)
 307 {
 308         return !(*this == asset);
 309 }
 310
 311 int Asset::test_path(const char *path)
 312 {
 313         if(!strcasecmp(this->path, path))
 314                 return 1;
 315         else
 316                 return 0;
 317 }
 318
 319 int Asset::test_plugin_title(const char *path)
 320 {
 321 }
 322
 323 int Asset::read(FileXML *file,
 324         int expand_relative)
 325 {
 326         return read(0, file, expand_relative);
 327 }
 328
 329 int Asset::read(ArrayList<PluginServer*> *plugindb,
 330         FileXML *file,
 331         int expand_relative)
 332 {
 333         int result = 0;
 334
 335 // Check for relative path.
 336         if(expand_relative)
 337         {
 338                 char new_path[BCTEXTLEN];
 339                 char asset_directory[BCTEXTLEN];
 340                 char input_directory[BCTEXTLEN];
 341                 FileSystem fs;
 342
 343                 strcpy(new_path, path);
 344                 fs.set_current_dir("");
 345
 346                 fs.extract_dir(asset_directory, path);
 347
 348 // No path in asset
 349                 if(!asset_directory[0])
 350                 {
 351                         fs.extract_dir(input_directory, file->filename);
 352
 353 // Input file has a path
 354                         if(input_directory[0])
 355                         {
 356                                 sprintf(path, "%s/%s", input_directory, new_path);
 357                         }
 358                 }
 359         }
 360
 361
 362         while(!result)
 363         {
 364                 result = file->read_tag();
 365                 if(!result)
 366                 {
 367                         if(file->tag.title_is("/ASSET"))
 368                         {
 369                                 result = 1;
 370                         }
 371                         else
 372                         if(file->tag.title_is("AUDIO"))
 373                         {
 374                                 read_audio(file);
 375                         }
 376                         else
 377                         if(file->tag.title_is("AUDIO_OMIT"))
 378                         {
 379                                 read_audio(file);
 380                         }
 381                         else
 382                         if(file->tag.title_is("FORMAT"))
 383                         {
 384                                 char *string = file->tag.get_property("TYPE");
 385                                 format = File::strtoformat(plugindb, string);
 386                                 use_header =
 387                                         file->tag.get_property("USE_HEADER", use_header);
 388                         }
 389                         else
 390                         if(file->tag.title_is("FOLDER"))
 391                         {
 392                                 strcpy(folder, file->read_text());
 393                         }
 394                         else
 395                         if(file->tag.title_is("VIDEO"))
 396                         {
 397                                 read_video(file);
 398                         }
 399                         else
 400                         if(file->tag.title_is("VIDEO_OMIT"))
 401                         {
 402                                 read_video(file);
 403                         }
 404                         else
 405                         if(file->tag.title_is("INDEX"))
 406                         {
 407                                 read_index(file);
 408                         }
 409                 }
 410         }
 411
 412 //printf("Asset::read 2\n");
 413         return 0;
 414 }
 415
 416 int Asset::read_audio(FileXML *file)
 417 {
 418         if(file->tag.title_is("AUDIO")) audio_data = 1;
 419         channels = file->tag.get_property("CHANNELS", 2);
 420 // This is loaded from the index file after the EDL but this
 421 // should be overridable in the EDL.
 422         if(!sample_rate) sample_rate = file->tag.get_property("RATE", 44100);
 423         bits = file->tag.get_property("BITS", 16);
 424         byte_order = file->tag.get_property("BYTE_ORDER", 1);
 425         signed_ = file->tag.get_property("SIGNED", 1);
 426         header = file->tag.get_property("HEADER", 0);
 427         dither = file->tag.get_property("DITHER", 0);
 428
 429         audio_length = file->tag.get_property("AUDIO_LENGTH", 0);
 430         acodec[0] = 0;
 431         file->tag.get_property("ACODEC", acodec);
 432
 433
 434
 435         ampeg_bitrate = file->tag.get_property("AMPEG_BITRATE", ampeg_bitrate);
 436         ampeg_derivative = file->tag.get_property("AMPEG_DERIVATIVE", ampeg_derivative);
 437
 438         vorbis_vbr = file->tag.get_property("VORBIS_VBR", vorbis_vbr);
 439         vorbis_min_bitrate = file->tag.get_property("VORBIS_MIN_BITRATE", vorbis_min_bitrate);
 440         vorbis_bitrate = file->tag.get_property("VORBIS_BITRATE", vorbis_bitrate);
 441         vorbis_max_bitrate = file->tag.get_property("VORBIS_MAX_BITRATE", vorbis_max_bitrate);
 442
 443         mp3_bitrate = file->tag.get_property("MP3_BITRATE", mp3_bitrate);
 444
 445
 446         return 0;
 447 }
 448
 449 int Asset::read_video(FileXML *file)
 450 {
 451         if(file->tag.title_is("VIDEO")) video_data = 1;
 452         height = file->tag.get_property("HEIGHT", height);
 453         width = file->tag.get_property("WIDTH", width);
 454         layers = file->tag.get_property("LAYERS", layers);
 455 // This is loaded from the index file after the EDL but this
 456 // should be overridable in the EDL.
 457         if(!frame_rate) frame_rate = file->tag.get_property("FRAMERATE", frame_rate);
 458         vcodec[0] = 0;
 459         file->tag.get_property("VCODEC", vcodec);
 460
 461         video_length = file->tag.get_property("VIDEO_LENGTH", 0);
 462
 463
 464
 465
 466         jpeg_quality = file->tag.get_property("JPEG_QUALITY", jpeg_quality);
 467         aspect_ratio = file->tag.get_property("ASPECT_RATIO", aspect_ratio);
 468
 469
 470
 471         vmpeg_iframe_distance = file->tag.get_property("VMPEG_IFRAME_DISTANCE", vmpeg_iframe_distance);
 472         vmpeg_bframe_distance = file->tag.get_property("VMPEG_BFRAME_DISTANCE", vmpeg_bframe_distance);
 473         vmpeg_progressive = file->tag.get_property("VMPEG_PROGRESSIVE", vmpeg_progressive);
 474         vmpeg_denoise = file->tag.get_property("VMPEG_DENOISE", vmpeg_denoise);
 475         vmpeg_bitrate = file->tag.get_property("VMPEG_BITRATE", vmpeg_bitrate);
 476         vmpeg_derivative = file->tag.get_property("VMPEG_DERIVATIVE", vmpeg_derivative);
 477         vmpeg_quantization = file->tag.get_property("VMPEG_QUANTIZATION", vmpeg_quantization);
 478         vmpeg_cmodel = file->tag.get_property("VMPEG_CMODEL", vmpeg_cmodel);
 479         vmpeg_fix_bitrate = file->tag.get_property("VMPEG_FIX_BITRATE", vmpeg_fix_bitrate);
 480         vmpeg_seq_codes = file->tag.get_property("VMPEG_SEQ_CODES", vmpeg_seq_codes);
 481
 482
 483         divx_bitrate = file->tag.get_property("DIVX_BITRATE", divx_bitrate);
 484         divx_rc_period = file->tag.get_property("DIVX_RC_PERIOD", divx_rc_period);
 485         divx_rc_reaction_ratio = file->tag.get_property("DIVX_RC_REACTION_RATIO", divx_rc_reaction_ratio);
 486         divx_rc_reaction_period = file->tag.get_property("DIVX_RC_REACTION_PERIOD", divx_rc_reaction_period);
 487         divx_max_key_interval = file->tag.get_property("DIVX_MAX_KEY_INTERVAL", divx_max_key_interval);
 488         divx_max_quantizer = file->tag.get_property("DIVX_MAX_QUANTIZER", divx_max_quantizer);
 489         divx_min_quantizer = file->tag.get_property("DIVX_MIN_QUANTIZER", divx_min_quantizer);
 490         divx_quantizer = file->tag.get_property("DIVX_QUANTIZER", divx_quantizer);
 491         divx_quality = file->tag.get_property("DIVX_QUALITY", divx_quality);
 492         divx_fix_bitrate = file->tag.get_property("DIVX_FIX_BITRATE", divx_fix_bitrate);
 493         divx_use_deblocking = file->tag.get_property("DIVX_USE_DEBLOCKING", divx_use_deblocking);
 494
 495         ms_bitrate = file->tag.get_property("MS_BITRATE", ms_bitrate);
 496         ms_bitrate_tolerance = file->tag.get_property("MS_BITRATE_TOLERANCE", ms_bitrate_tolerance);
 497         ms_interlaced = file->tag.get_property("MS_INTERLACED", ms_interlaced);
 498         ms_quantization = file->tag.get_property("MS_QUANTIZATION", ms_quantization);
 499         ms_gop_size = file->tag.get_property("MS_GOP_SIZE", ms_gop_size);
 500         ms_fix_bitrate = file->tag.get_property("MS_FIX_BITRATE", ms_fix_bitrate);
 501
 502
 503         ac3_bitrate = file->tag.get_property("AC3_BITRATE", ac3_bitrate);
 504
 505
 506         png_use_alpha = file->tag.get_property("PNG_USE_ALPHA", png_use_alpha);
 507         exr_use_alpha = file->tag.get_property("EXR_USE_ALPHA", exr_use_alpha);
 508         exr_compression = file->tag.get_property("EXR_COMPRESSION", exr_compression);
 509
 510         tiff_cmodel = file->tag.get_property("TIFF_CMODEL", tiff_cmodel);
 511         tiff_compression = file->tag.get_property("TIFF_COMPRESSION", tiff_compression);
 512
 513         return 0;
 514 }
 515
 516 int Asset::read_index(FileXML *file)
 517 {
 518         if(index_offsets) delete [] index_offsets;
 519         index_offsets = new int64_t[channels];
 520         for(int i = 0; i < channels; i++) index_offsets[i] = 0;
 521
 522         int current_offset = 0;
 523         int result = 0;
 524
 525         index_zoom = file->tag.get_property("ZOOM", 1);
 526         index_bytes = file->tag.get_property("BYTES", (int64_t)0);
 527
 528         while(!result)
 529         {
 530                 result = file->read_tag();
 531                 if(!result)
 532                 {
 533                         if(file->tag.title_is("/INDEX"))
 534                         {
 535                                 result = 1;
 536                         }
 537                         else
 538                         if(file->tag.title_is("OFFSET"))
 539                         {
 540                                 if(current_offset < channels)
 541                                 {
 542                                         index_offsets[current_offset++] = file->tag.get_property("FLOAT", 0);
 543 //printf("Asset::read_index %d %d\n", current_offset - 1, index_offsets[current_offset - 1]);
 544                                 }
 545                         }
 546                 }
 547         }
 548         return 0;
 549 }
 550
 551 // Output path is the path of the output file if name truncation is desired.
 552 // It is a "" if complete names should be used.
 553
 554 int Asset::write(FileXML *file,
 555         int include_index,
 556         char *output_path)
 557 {
 558         write(0,
 559                 file,
 560                 include_index,
 561                 output_path);
 562 }
 563
 564 int Asset::write(ArrayList<PluginServer*> *plugindb,
 565         FileXML *file,
 566         int include_index,
 567         char *output_path)
 568 {
 569         char new_path[BCTEXTLEN];
 570         char asset_directory[BCTEXTLEN];
 571         char output_directory[BCTEXTLEN];
 572         FileSystem fs;
 573
 574 // Make path relative
 575         fs.extract_dir(asset_directory, path);
 576         if(output_path && output_path[0])
 577                 fs.extract_dir(output_directory, output_path);
 578         else
 579                 output_directory[0] = 0;
 580
 581 // Asset and EDL are in same directory.  Extract just the name.
 582         if(!strcmp(asset_directory, output_directory))
 583         {
 584                 fs.extract_name(new_path, path);
 585         }
 586         else
 587         {
 588                 strcpy(new_path, path);
 589         }
 590
 591         file->tag.set_title("ASSET");
 592         file->tag.set_property("SRC", new_path);
 593         file->append_tag();
 594         file->append_newline();
 595
 596         file->tag.set_title("FOLDER");
 597         file->append_tag();
 598         file->append_text(folder);
 599         file->tag.set_title("/FOLDER");
 600         file->append_tag();
 601         file->append_newline();
 602
 603 // Write the format information
 604         file->tag.set_title("FORMAT");
 605
 606         file->tag.set_property("TYPE",
 607                 File::formattostr(plugindb, format));
 608         file->tag.set_property("USE_HEADER", use_header);
 609
 610         file->append_tag();
 611         file->tag.set_title("/FORMAT");
 612         file->append_tag();
 613         file->append_newline();
 614
 615 // Requiring data to exist caused batch render to lose settings.
 616 // But the only way to know if an asset doesn't have audio or video data
 617 // is to not write the block.
 618 // So change the block name if the asset doesn't have the data.
 619         /* if(audio_data) */ write_audio(file);
 620         /* if(video_data) */ write_video(file);
 621         if(index_status == 0 && include_index) write_index(file);  // index goes after source
 622
 623         file->tag.set_title("/ASSET");
 624         file->append_tag();
 625         file->append_newline();
 626         return 0;
 627 }
 628
 629 int Asset::write_audio(FileXML *file)
 630 {
 631 // Let the reader know if the asset has the data by naming the block.
 632         if(audio_data)
 633                 file->tag.set_title("AUDIO");
 634         else
 635                 file->tag.set_title("AUDIO_OMIT");
 636         file->tag.set_property("CHANNELS", channels);
 637         file->tag.set_property("RATE", sample_rate);
 638         file->tag.set_property("BITS", bits);
 639         file->tag.set_property("BYTE_ORDER", byte_order);
 640         file->tag.set_property("SIGNED", signed_);
 641         file->tag.set_property("HEADER", header);
 642         file->tag.set_property("DITHER", dither);
 643         if(acodec[0])
 644                 file->tag.set_property("ACODEC", acodec);
 645
 646         file->tag.set_property("AUDIO_LENGTH", audio_length);
 647
 648
 649
 650
 651         file->tag.set_property("AMPEG_BITRATE", ampeg_bitrate);
 652         file->tag.set_property("AMPEG_DERIVATIVE", ampeg_derivative);
 653
 654         file->tag.set_property("VORBIS_VBR", vorbis_vbr);
 655         file->tag.set_property("VORBIS_MIN_BITRATE", vorbis_min_bitrate);
 656         file->tag.set_property("VORBIS_BITRATE", vorbis_bitrate);
 657         file->tag.set_property("VORBIS_MAX_BITRATE", vorbis_max_bitrate);
 658
 659         file->tag.set_property("MP3_BITRATE", mp3_bitrate);
 660
 661
 662
 663
 664         file->append_tag();
 665         if(audio_data)
 666           file->tag.set_title("/AUDIO");
 667         else
 668           file->tag.set_title("/AUDIO_OMIT");
 669         file->append_tag();
 670         file->append_newline();
 671         return 0;
 672 }
 673
 674 int Asset::write_video(FileXML *file)
 675 {
 676         if(video_data)
 677                 file->tag.set_title("VIDEO");
 678         else
 679                 file->tag.set_title("VIDEO_OMIT");
 680         file->tag.set_property("HEIGHT", height);
 681         file->tag.set_property("WIDTH", width);
 682         file->tag.set_property("LAYERS", layers);
 683         file->tag.set_property("FRAMERATE", frame_rate);
 684         if(vcodec[0])
 685                 file->tag.set_property("VCODEC", vcodec);
 686
 687         file->tag.set_property("VIDEO_LENGTH", video_length);
 688
 689
 690
 691         file->tag.set_property("JPEG_QUALITY", jpeg_quality);
 692         file->tag.set_property("ASPECT_RATIO", aspect_ratio);
 693
 694         file->tag.set_property("VMPEG_IFRAME_DISTANCE", vmpeg_iframe_distance);
 695         file->tag.set_property("VMPEG_BFRAME_DISTANCE", vmpeg_bframe_distance);
 696         file->tag.set_property("VMPEG_PROGRESSIVE", vmpeg_progressive);
 697         file->tag.set_property("VMPEG_DENOISE", vmpeg_denoise);
 698         file->tag.set_property("VMPEG_BITRATE", vmpeg_bitrate);
 699         file->tag.set_property("VMPEG_DERIVATIVE", vmpeg_derivative);
 700         file->tag.set_property("VMPEG_QUANTIZATION", vmpeg_quantization);
 701         file->tag.set_property("VMPEG_CMODEL", vmpeg_cmodel);
 702         file->tag.set_property("VMPEG_FIX_BITRATE", vmpeg_fix_bitrate);
 703         file->tag.set_property("VMPEG_SEQ_CODES", vmpeg_seq_codes);
 704
 705
 706         file->tag.set_property("DIVX_BITRATE", divx_bitrate);
 707         file->tag.set_property("DIVX_RC_PERIOD", divx_rc_period);
 708         file->tag.set_property("DIVX_RC_REACTION_RATIO", divx_rc_reaction_ratio);
 709         file->tag.set_property("DIVX_RC_REACTION_PERIOD", divx_rc_reaction_period);
 710         file->tag.set_property("DIVX_MAX_KEY_INTERVAL", divx_max_key_interval);
 711         file->tag.set_property("DIVX_MAX_QUANTIZER", divx_max_quantizer);
 712         file->tag.set_property("DIVX_MIN_QUANTIZER", divx_min_quantizer);
 713         file->tag.set_property("DIVX_QUANTIZER", divx_quantizer);
 714         file->tag.set_property("DIVX_QUALITY", divx_quality);
 715         file->tag.set_property("DIVX_FIX_BITRATE", divx_fix_bitrate);
 716         file->tag.set_property("DIVX_USE_DEBLOCKING", divx_use_deblocking);
 717
 718
 719         file->tag.set_property("MS_BITRATE", ms_bitrate);
 720         file->tag.set_property("MS_BITRATE_TOLERANCE", ms_bitrate_tolerance);
 721         file->tag.set_property("MS_INTERLACED", ms_interlaced);
 722         file->tag.set_property("MS_QUANTIZATION", ms_quantization);
 723         file->tag.set_property("MS_GOP_SIZE", ms_gop_size);
 724         file->tag.set_property("MS_FIX_BITRATE", ms_fix_bitrate);
 725
 726
 727         file->tag.set_property("AC3_BITRATE", ac3_bitrate);
 728
 729         file->tag.set_property("PNG_USE_ALPHA", png_use_alpha);
 730
 731         file->tag.set_property("EXR_USE_ALPHA", exr_use_alpha);
 732         file->tag.set_property("EXR_COMPRESSION", exr_compression);
 733
 734         file->tag.set_property("TIFF_CMODEL", tiff_cmodel);
 735         file->tag.set_property("TIFF_COMPRESSION", tiff_compression);
 736
 737
 738
 739         file->append_tag();
 740         file->tag.set_title("/VIDEO");
 741         file->append_tag();
 742         file->append_newline();
 743         return 0;
 744 }
 745
 746 int Asset::write_index(FileXML *file)
 747 {
 748         file->tag.set_title("INDEX");
 749         file->tag.set_property("ZOOM", index_zoom);
 750         file->tag.set_property("BYTES", index_bytes);
 751         file->append_tag();
 752         file->append_newline();
 753
 754         if(index_offsets)
 755         {
 756                 for(int i = 0; i < channels; i++)
 757                 {
 758                         file->tag.set_title("OFFSET");
 759                         file->tag.set_property("FLOAT", index_offsets[i]);
 760                         file->append_tag();
 761                         file->tag.set_title("/OFFSET");
 762                         file->append_tag();
 763                 }
 764         }
 765
 766         file->append_newline();
 767         file->tag.set_title("/INDEX");
 768         file->append_tag();
 769         file->append_newline();
 770         return 0;
 771 }
 772
 773
 774
 775
 776 char* Asset::construct_param(char *param, char *prefix, char *return_value)
 777 {
 778         if(prefix)
 779                 sprintf(return_value, "%s%s", prefix, param);
 780         else
 781                 strcpy(return_value, param);
 782         return return_value;
 783 }
 784
 785 #define UPDATE_DEFAULT(x, y) defaults->update(construct_param(x, prefix, string), y);
 786 #define GET_DEFAULT(x, y) defaults->get(construct_param(x, prefix, string), y);
 787
 788 void Asset::load_defaults(Defaults *defaults,
 789         char *prefix,
 790         int do_format,
 791         int do_compression,
 792         int do_path,
 793         int do_data_types,
 794         int do_bits)
 795 {
 796         char string[BCTEXTLEN];
 797
 798 // Can't save codec here because it's specific to render, record, and effect.
 799 // The codec has to be UNKNOWN for file probing to work.
 800
 801         if(do_path)
 802         {
 803                 GET_DEFAULT("PATH", path);
 804         }
 805
 806         if(do_compression)
 807         {
 808                 GET_DEFAULT("AUDIO_CODEC", acodec);
 809                 GET_DEFAULT("VIDEO_CODEC", vcodec);
 810         }
 811
 812         if(do_format)
 813         {
 814                 format = GET_DEFAULT("FORMAT", format);
 815         }
 816
 817         if(do_data_types)
 818         {
 819                 audio_data = GET_DEFAULT("AUDIO", 1);
 820                 video_data = GET_DEFAULT("VIDEO", 1);
 821         }
 822
 823         if(do_bits)
 824         {
 825                 bits = GET_DEFAULT("BITS", 16);
 826                 dither = GET_DEFAULT("DITHER", 0);
 827                 signed_ = GET_DEFAULT("SIGNED", 1);
 828                 byte_order = GET_DEFAULT("BYTE_ORDER", 1);
 829         }
 830
 831         ampeg_bitrate = GET_DEFAULT("AMPEG_BITRATE", ampeg_bitrate);
 832         ampeg_derivative = GET_DEFAULT("AMPEG_DERIVATIVE", ampeg_derivative);
 833
 834         vorbis_vbr = GET_DEFAULT("VORBIS_VBR", vorbis_vbr);
 835         vorbis_min_bitrate = GET_DEFAULT("VORBIS_MIN_BITRATE", vorbis_min_bitrate);
 836         vorbis_bitrate = GET_DEFAULT("VORBIS_BITRATE", vorbis_bitrate);
 837         vorbis_max_bitrate = GET_DEFAULT("VORBIS_MAX_BITRATE", vorbis_max_bitrate);
 838
 839         mp3_bitrate = GET_DEFAULT("MP3_BITRATE", mp3_bitrate);
 840
 841
 842
 843         jpeg_quality = GET_DEFAULT("JPEG_QUALITY", jpeg_quality);
 844         aspect_ratio = GET_DEFAULT("ASPECT_RATIO", aspect_ratio);
 845
 846 // MPEG format information
 847         vmpeg_iframe_distance = GET_DEFAULT("VMPEG_IFRAME_DISTANCE", vmpeg_iframe_distance);
 848         vmpeg_bframe_distance = GET_DEFAULT("VMPEG_BFRAME_DISTANCE", vmpeg_bframe_distance);
 849         vmpeg_progressive = GET_DEFAULT("VMPEG_PROGRESSIVE", vmpeg_progressive);
 850         vmpeg_denoise = GET_DEFAULT("VMPEG_DENOISE", vmpeg_denoise);
 851         vmpeg_bitrate = GET_DEFAULT("VMPEG_BITRATE", vmpeg_bitrate);
 852         vmpeg_derivative = GET_DEFAULT("VMPEG_DERIVATIVE", vmpeg_derivative);
 853         vmpeg_quantization = GET_DEFAULT("VMPEG_QUANTIZATION", vmpeg_quantization);
 854         vmpeg_cmodel = GET_DEFAULT("VMPEG_CMODEL", vmpeg_cmodel);
 855         vmpeg_fix_bitrate = GET_DEFAULT("VMPEG_FIX_BITRATE", vmpeg_fix_bitrate);
 856         vmpeg_seq_codes = GET_DEFAULT("VMPEG_SEQ_CODES", vmpeg_seq_codes);
 857
 858
 859         divx_bitrate = GET_DEFAULT("DIVX_BITRATE", divx_bitrate);
 860         divx_rc_period = GET_DEFAULT("DIVX_RC_PERIOD", divx_rc_period);
 861         divx_rc_reaction_ratio = GET_DEFAULT("DIVX_RC_REACTION_RATIO", divx_rc_reaction_ratio);
 862         divx_rc_reaction_period = GET_DEFAULT("DIVX_RC_REACTION_PERIOD", divx_rc_reaction_period);
 863         divx_max_key_interval = GET_DEFAULT("DIVX_MAX_KEY_INTERVAL", divx_max_key_interval);
 864         divx_max_quantizer = GET_DEFAULT("DIVX_MAX_QUANTIZER", divx_max_quantizer);
 865         divx_min_quantizer = GET_DEFAULT("DIVX_MIN_QUANTIZER", divx_min_quantizer);
 866         divx_quantizer = GET_DEFAULT("DIVX_QUANTIZER", divx_quantizer);
 867         divx_quality = GET_DEFAULT("DIVX_QUALITY", divx_quality);
 868         divx_fix_bitrate = GET_DEFAULT("DIVX_FIX_BITRATE", divx_fix_bitrate);
 869         divx_use_deblocking = GET_DEFAULT("DIVX_USE_DEBLOCKING", divx_use_deblocking);
 870
 871         ms_bitrate = GET_DEFAULT("MS_BITRATE", ms_bitrate);
 872         ms_bitrate_tolerance = GET_DEFAULT("MS_BITRATE_TOLERANCE", ms_bitrate_tolerance);
 873         ms_interlaced = GET_DEFAULT("MS_INTERLACED", ms_interlaced);
 874         ms_quantization = GET_DEFAULT("MS_QUANTIZATION", ms_quantization);
 875         ms_gop_size = GET_DEFAULT("MS_GOP_SIZE", ms_gop_size);
 876         ms_fix_bitrate = GET_DEFAULT("MS_FIX_BITRATE", ms_fix_bitrate);
 877
 878         ac3_bitrate = GET_DEFAULT("AC3_BITRATE", ac3_bitrate);
 879
 880         png_use_alpha = GET_DEFAULT("PNG_USE_ALPHA", png_use_alpha);
 881         exr_use_alpha = GET_DEFAULT("EXR_USE_ALPHA", exr_use_alpha);
 882         exr_compression = GET_DEFAULT("EXR_COMPRESSION", exr_compression);
 883         tiff_cmodel = GET_DEFAULT("TIFF_CMODEL", tiff_cmodel);
 884         tiff_compression = GET_DEFAULT("TIFF_COMPRESSION", tiff_compression);
 885 }
 886
 887 void Asset::save_defaults(Defaults *defaults,
 888         char *prefix,
 889         int do_format,
 890         int do_compression,
 891         int do_path,
 892         int do_data_types,
 893         int do_bits)
 894 {
 895         char string[BCTEXTLEN];
 896
 897         UPDATE_DEFAULT("PATH", path);
 898
 899         if(do_format)
 900         {
 901                 UPDATE_DEFAULT("FORMAT", format);
 902         }
 903
 904         if(do_data_types)
 905         {
 906                 UPDATE_DEFAULT("AUDIO", audio_data);
 907                 UPDATE_DEFAULT("VIDEO", video_data);
 908         }
 909
 910         if(do_compression)
 911         {
 912                 UPDATE_DEFAULT("AUDIO_CODEC", acodec);
 913                 UPDATE_DEFAULT("VIDEO_CODEC", vcodec);
 914         }
 915
 916         if(do_bits)
 917         {
 918                 UPDATE_DEFAULT("BITS", bits);
 919                 UPDATE_DEFAULT("DITHER", dither);
 920                 UPDATE_DEFAULT("SIGNED", signed_);
 921                 UPDATE_DEFAULT("BYTE_ORDER", byte_order);
 922         }
 923
 924         UPDATE_DEFAULT("AMPEG_BITRATE", ampeg_bitrate);
 925         UPDATE_DEFAULT("AMPEG_DERIVATIVE", ampeg_derivative);
 926
 927         UPDATE_DEFAULT("VORBIS_VBR", vorbis_vbr);
 928         UPDATE_DEFAULT("VORBIS_MIN_BITRATE", vorbis_min_bitrate);
 929         UPDATE_DEFAULT("VORBIS_BITRATE", vorbis_bitrate);
 930         UPDATE_DEFAULT("VORBIS_MAX_BITRATE", vorbis_max_bitrate);
 931
 932         UPDATE_DEFAULT("MP3_BITRATE", mp3_bitrate);
 933
 934
 935
 936
 937
 938         UPDATE_DEFAULT("JPEG_QUALITY", jpeg_quality);
 939         UPDATE_DEFAULT("ASPECT_RATIO", aspect_ratio);
 940
 941 // MPEG format information
 942         UPDATE_DEFAULT("VMPEG_IFRAME_DISTANCE", vmpeg_iframe_distance);
 943         UPDATE_DEFAULT("VMPEG_BFRAME_DISTANCE", vmpeg_bframe_distance);
 944         UPDATE_DEFAULT("VMPEG_PROGRESSIVE", vmpeg_progressive);
 945         UPDATE_DEFAULT("VMPEG_DENOISE", vmpeg_denoise);
 946         UPDATE_DEFAULT("VMPEG_BITRATE", vmpeg_bitrate);
 947         UPDATE_DEFAULT("VMPEG_DERIVATIVE", vmpeg_derivative);
 948         UPDATE_DEFAULT("VMPEG_QUANTIZATION", vmpeg_quantization);
 949         UPDATE_DEFAULT("VMPEG_CMODEL", vmpeg_cmodel);
 950         UPDATE_DEFAULT("VMPEG_FIX_BITRATE", vmpeg_fix_bitrate);
 951         UPDATE_DEFAULT("VMPEG_SEQ_CODES", vmpeg_seq_codes);
 952
 953
 954
 955         UPDATE_DEFAULT("DIVX_BITRATE", divx_bitrate);
 956         UPDATE_DEFAULT("DIVX_RC_PERIOD", divx_rc_period);
 957         UPDATE_DEFAULT("DIVX_RC_REACTION_RATIO", divx_rc_reaction_ratio);
 958         UPDATE_DEFAULT("DIVX_RC_REACTION_PERIOD", divx_rc_reaction_period);
 959         UPDATE_DEFAULT("DIVX_MAX_KEY_INTERVAL", divx_max_key_interval);
 960         UPDATE_DEFAULT("DIVX_MAX_QUANTIZER", divx_max_quantizer);
 961         UPDATE_DEFAULT("DIVX_MIN_QUANTIZER", divx_min_quantizer);
 962         UPDATE_DEFAULT("DIVX_QUANTIZER", divx_quantizer);
 963         UPDATE_DEFAULT("DIVX_QUALITY", divx_quality);
 964         UPDATE_DEFAULT("DIVX_FIX_BITRATE", divx_fix_bitrate);
 965         UPDATE_DEFAULT("DIVX_USE_DEBLOCKING", divx_use_deblocking);
 966
 967
 968         UPDATE_DEFAULT("MS_BITRATE", ms_bitrate);
 969         UPDATE_DEFAULT("MS_BITRATE_TOLERANCE", ms_bitrate_tolerance);
 970         UPDATE_DEFAULT("MS_INTERLACED", ms_interlaced);
 971         UPDATE_DEFAULT("MS_QUANTIZATION", ms_quantization);
 972         UPDATE_DEFAULT("MS_GOP_SIZE", ms_gop_size);
 973         UPDATE_DEFAULT("MS_FIX_BITRATE", ms_fix_bitrate);
 974
 975         UPDATE_DEFAULT("AC3_BITRATE", ac3_bitrate);
 976
 977
 978         UPDATE_DEFAULT("PNG_USE_ALPHA", png_use_alpha);
 979         UPDATE_DEFAULT("EXR_USE_ALPHA", exr_use_alpha);
 980         UPDATE_DEFAULT("EXR_COMPRESSION", exr_compression);
 981         UPDATE_DEFAULT("TIFF_CMODEL", tiff_cmodel);
 982         UPDATE_DEFAULT("TIFF_COMPRESSION", tiff_compression);
 983 }
 984
 985
 986
 987
 988
 989
 990
 991
 992
 993 int Asset::update_path(char *new_path)
 994 {
 995         strcpy(path, new_path);
 996         return 0;
 997 }
 998
 999 void Asset::update_index(Asset *asset)
1000 {
1001 //printf("Asset::update_index 1 %d\n", index_status);
1002         index_status = asset->index_status;
1003         index_zoom = asset->index_zoom;          // zoom factor of index data
1004         index_start = asset->index_start;        // byte start of index data in the index file
1005         index_bytes = asset->index_bytes;        // Total bytes in source file for comparison before rebuilding the index
1006         index_end = asset->index_end;
1007         old_index_end = asset->old_index_end;    // values for index build
1008 //printf("Asset::update_index 1\n");
1009
1010         if(index_offsets)
1011         {
1012                 delete [] index_offsets;
1013                 index_offsets = 0;
1014         }
1015
1016         if(asset->index_offsets)
1017         {
1018                 index_offsets = new int64_t[asset->channels];
1019 //printf("Asset::update_index 1\n");
1020
1021                 int i;
1022                 for(i = 0; i < asset->channels; i++)
1023                 {
1024                         index_offsets[i] = asset->index_offsets[i];  // offsets of channels in index file in floats
1025
1026                 }
1027         }
1028 //printf("Asset::update_index 1\n");
1029         index_buffer = asset->index_buffer;    // pointer
1030 //printf("Asset::update_index 2\n");
1031 }
1032
1033 void Asset::set_frame_start(int64_t value)
1034 {
1035         frame_start = value;
1036 }
1037
1038 int Asset::dump()
1039 {
1040         printf("  asset::dump\n");
1041         printf("   %p %s\n", this, path);
1042         printf("   index_status %d\n", index_status);
1043         printf("   format %d\n", format);
1044         printf("   audio_data %d channels %d samplerate %d bits %d byte_order %d signed %d header %d dither %d acodec %c%c%c%c\n",
1045                 audio_data, channels, sample_rate, bits, byte_order, signed_, header, dither, acodec[0], acodec[1], acodec[2], acodec[3]);
1046         printf("   audio_length %lld\n", audio_length);
1047         printf("   video_data %d layers %d framerate %f width %d height %d vcodec %c%c%c%c aspect_ratio %f\n",
1048                 video_data, layers, frame_rate, width, height, vcodec[0], vcodec[1], vcodec[2], vcodec[3], aspect_ratio);
1049         printf("   video_length %lld \n", video_length);
1050         printf("   frame_start %d\n", frame_start);
1051         return 0;
1052 }
1053
1054