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 #include "interlacemodes.h"
  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         delete [] index_offsets;
  40         delete [] index_sizes;
  41 // Don't delete index buffer since it is shared with the index thread.
  42 }
  43
  44
  45 int Asset::init_values()
  46 {
  47         path[0] = 0;
  48         strcpy(folder, MEDIA_FOLDER);
  49 //      format = FILE_MOV;
  50 // Has to be unknown for file probing to succeed
  51         format = FILE_UNKNOWN;
  52         channels = 0;
  53         sample_rate = 0;
  54         bits = 0;
  55         byte_order = 0;
  56         signed_ = 0;
  57         header = 0;
  58         dither = 0;
  59         audio_data = 0;
  60         video_data = 0;
  61         audio_length = 0;
  62         video_length = 0;
  63
  64         layers = 0;
  65         frame_rate = 0;
  66         width = 0;
  67         height = 0;
  68         strcpy(vcodec, QUICKTIME_YUV2);
  69         strcpy(acodec, QUICKTIME_TWOS);
  70         jpeg_quality = 100;
  71         aspect_ratio = -1;
  72         interlace_autofixoption = BC_ILACE_AUTOFIXOPTION_AUTO;
  73         interlace_mode = BC_ILACE_MODE_UNDETECTED;
  74         interlace_fixmethod = BC_ILACE_FIXMETHOD_NONE;
  75
  76         ampeg_bitrate = 256;
  77         ampeg_derivative = 3;
  78
  79         vorbis_vbr = 0;
  80         vorbis_min_bitrate = -1;
  81         vorbis_bitrate = 128000;
  82         vorbis_max_bitrate = -1;
  83
  84         theora_fix_bitrate = 1;
  85         theora_bitrate = 860000;
  86         theora_quality = 16;
  87         theora_sharpness = 2;
  88         theora_keyframe_frequency = 64;
  89         theora_keyframe_force_frequency = 64;
  90
  91         mp3_bitrate = 256000;
  92
  93
  94         mp4a_bitrate = 256000;
  95         mp4a_quantqual = 100;
  96
  97
  98
  99 // mpeg parameters
 100         vmpeg_iframe_distance = 45;
 101         vmpeg_pframe_distance = 0;
 102         vmpeg_progressive = 0;
 103         vmpeg_denoise = 1;
 104         vmpeg_bitrate = 1000000;
 105         vmpeg_derivative = 1;
 106         vmpeg_quantization = 15;
 107         vmpeg_cmodel = 0;
 108         vmpeg_fix_bitrate = 0;
 109         vmpeg_seq_codes = 0;
 110         vmpeg_preset = 0;
 111         vmpeg_field_order = 0;
 112
 113 // Divx parameters.  Defaults from encore2
 114         divx_bitrate = 2000000;
 115         divx_rc_period = 50;
 116         divx_rc_reaction_ratio = 45;
 117         divx_rc_reaction_period = 10;
 118         divx_max_key_interval = 250;
 119         divx_max_quantizer = 31;
 120         divx_min_quantizer = 1;
 121         divx_quantizer = 5;
 122         divx_quality = 5;
 123         divx_fix_bitrate = 1;
 124         divx_use_deblocking = 1;
 125
 126         h264_bitrate = 2000000;
 127         h264_quantizer = 5;
 128         h264_fix_bitrate = 0;
 129
 130         ms_bitrate = 1000000;
 131         ms_bitrate_tolerance = 500000;
 132         ms_quantization = 10;
 133         ms_interlaced = 0;
 134         ms_gop_size = 45;
 135         ms_fix_bitrate = 1;
 136
 137         ac3_bitrate = 128;
 138
 139         png_use_alpha = 0;
 140         exr_use_alpha = 0;
 141         exr_compression = 0;
 142
 143         tiff_cmodel = 0;
 144         tiff_compression = 0;
 145
 146         use_header = 1;
 147
 148
 149         reset_index();
 150         id = EDL::next_id();
 151
 152         pipe[0] = 0;
 153         use_pipe = 0;
 154
 155         strcpy(prefix, "");
 156
 157         reset_timecode();
 158
 159         return 0;
 160 }
 161
 162 int Asset::reset_index()
 163 {
 164         index_status = INDEX_NOTTESTED;
 165         index_start = old_index_end = index_end = 0;
 166         index_offsets = 0;
 167         index_sizes = 0;
 168         index_zoom = 0;
 169         index_bytes = 0;
 170         index_buffer = 0;
 171         return 0;
 172 }
 173
 174 int Asset::reset_timecode()
 175 {
 176         strcpy(reel_name, "cin0000");
 177         reel_number = 0;
 178         tcstart = 0;
 179         tcend = 0;
 180         tcformat = 0;
 181
 182         return 0;
 183 }
 184
 185 void Asset::copy_from(Asset *asset, int do_index)
 186 {
 187         copy_location(asset);
 188         copy_format(asset, do_index);
 189 }
 190
 191 void Asset::copy_location(Asset *asset)
 192 {
 193         strcpy(this->path, asset->path);
 194         strcpy(this->folder, asset->folder);
 195 }
 196
 197 void Asset::copy_format(Asset *asset, int do_index)
 198 {
 199         if(do_index) update_index(asset);
 200
 201         audio_data = asset->audio_data;
 202         format = asset->format;
 203         channels = asset->channels;
 204         sample_rate = asset->sample_rate;
 205         bits = asset->bits;
 206         byte_order = asset->byte_order;
 207         signed_ = asset->signed_;
 208         header = asset->header;
 209         dither = asset->dither;
 210         mp3_bitrate = asset->mp3_bitrate;
 211         mp4a_bitrate = asset->mp4a_bitrate;
 212         mp4a_quantqual = asset->mp4a_quantqual;
 213         use_header = asset->use_header;
 214         aspect_ratio = asset->aspect_ratio;
 215         interlace_autofixoption = asset->interlace_autofixoption;
 216         interlace_mode = asset->interlace_mode;
 217         interlace_fixmethod = asset->interlace_fixmethod;
 218
 219         video_data = asset->video_data;
 220         layers = asset->layers;
 221         frame_rate = asset->frame_rate;
 222         width = asset->width;
 223         height = asset->height;
 224         strcpy(vcodec, asset->vcodec);
 225         strcpy(acodec, asset->acodec);
 226
 227         this->audio_length = asset->audio_length;
 228         this->video_length = asset->video_length;
 229
 230
 231         ampeg_bitrate = asset->ampeg_bitrate;
 232         ampeg_derivative = asset->ampeg_derivative;
 233
 234
 235         vorbis_vbr = asset->vorbis_vbr;
 236         vorbis_min_bitrate = asset->vorbis_min_bitrate;
 237         vorbis_bitrate = asset->vorbis_bitrate;
 238         vorbis_max_bitrate = asset->vorbis_max_bitrate;
 239
 240         theora_fix_bitrate = asset->theora_fix_bitrate;
 241         theora_bitrate = asset->theora_bitrate;
 242         theora_quality = asset->theora_quality;
 243         theora_sharpness = asset->theora_sharpness;
 244         theora_keyframe_frequency = asset->theora_keyframe_frequency;
 245         theora_keyframe_force_frequency = asset->theora_keyframe_frequency;
 246
 247
 248         theora_fix_bitrate = asset->theora_fix_bitrate;
 249         theora_bitrate = asset->theora_bitrate;
 250         theora_quality = asset->theora_quality;
 251         theora_sharpness = asset->theora_sharpness;
 252         theora_keyframe_frequency = asset->theora_keyframe_frequency;
 253         theora_keyframe_force_frequency = asset->theora_keyframe_frequency;
 254
 255
 256         jpeg_quality = asset->jpeg_quality;
 257
 258 // mpeg parameters
 259         vmpeg_iframe_distance = asset->vmpeg_iframe_distance;
 260         vmpeg_pframe_distance = asset->vmpeg_pframe_distance;
 261         vmpeg_progressive = asset->vmpeg_progressive;
 262         vmpeg_denoise = asset->vmpeg_denoise;
 263         vmpeg_bitrate = asset->vmpeg_bitrate;
 264         vmpeg_derivative = asset->vmpeg_derivative;
 265         vmpeg_quantization = asset->vmpeg_quantization;
 266         vmpeg_cmodel = asset->vmpeg_cmodel;
 267         vmpeg_fix_bitrate = asset->vmpeg_fix_bitrate;
 268         vmpeg_seq_codes = asset->vmpeg_seq_codes;
 269         vmpeg_preset = asset->vmpeg_preset;
 270         vmpeg_field_order = asset->vmpeg_field_order;
 271
 272
 273         divx_bitrate = asset->divx_bitrate;
 274         divx_rc_period = asset->divx_rc_period;
 275         divx_rc_reaction_ratio = asset->divx_rc_reaction_ratio;
 276         divx_rc_reaction_period = asset->divx_rc_reaction_period;
 277         divx_max_key_interval = asset->divx_max_key_interval;
 278         divx_max_quantizer = asset->divx_max_quantizer;
 279         divx_min_quantizer = asset->divx_min_quantizer;
 280         divx_quantizer = asset->divx_quantizer;
 281         divx_quality = asset->divx_quality;
 282         divx_fix_bitrate = asset->divx_fix_bitrate;
 283         divx_use_deblocking = asset->divx_use_deblocking;
 284
 285         h264_bitrate = asset->h264_bitrate;
 286         h264_quantizer = asset->h264_quantizer;
 287         h264_fix_bitrate = asset->h264_fix_bitrate;
 288
 289
 290         ms_bitrate = asset->ms_bitrate;
 291         ms_bitrate_tolerance = asset->ms_bitrate_tolerance;
 292         ms_interlaced = asset->ms_interlaced;
 293         ms_quantization = asset->ms_quantization;
 294         ms_gop_size = asset->ms_gop_size;
 295         ms_fix_bitrate = asset->ms_fix_bitrate;
 296
 297
 298         ac3_bitrate = asset->ac3_bitrate;
 299
 300         png_use_alpha = asset->png_use_alpha;
 301         exr_use_alpha = asset->exr_use_alpha;
 302         exr_compression = asset->exr_compression;
 303
 304         tiff_cmodel = asset->tiff_cmodel;
 305         tiff_compression = asset->tiff_compression;
 306
 307         strcpy(pipe, asset->pipe);
 308         use_pipe = asset->use_pipe;
 309
 310         // FUTURE: should this be here or in copy_from()?
 311         strcpy(prefix, asset->prefix);
 312
 313         strcpy(reel_name, asset->reel_name);
 314         reel_number = asset->reel_number;
 315         tcstart = asset->tcstart;
 316         tcend = asset->tcend;
 317         tcformat = asset->tcformat;
 318 }
 319
 320 int64_t Asset::get_index_offset(int channel)
 321 {
 322         if(channel < channels && index_offsets)
 323                 return index_offsets[channel];
 324         else
 325                 return 0;
 326 }
 327
 328 int64_t Asset::get_index_size(int channel)
 329 {
 330         if(channel < channels && index_sizes)
 331                 return index_sizes[channel];
 332         else
 333                 return 0;
 334 }
 335
 336
 337 char* Asset::get_compression_text(int audio, int video)
 338 {
 339         if(audio)
 340         {
 341                 switch(format)
 342                 {
 343                         case FILE_MOV:
 344                         case FILE_AVI:
 345                                 if(acodec[0])
 346                                         return quicktime_acodec_title(acodec);
 347                                 else
 348                                         return 0;
 349                                 break;
 350                 }
 351         }
 352         else
 353         if(video)
 354         {
 355                 switch(format)
 356                 {
 357                         case FILE_MOV:
 358                         case FILE_AVI:
 359                                 if(vcodec[0])
 360                                         return quicktime_vcodec_title(vcodec);
 361                                 else
 362                                         return 0;
 363                                 break;
 364                 }
 365         }
 366         return 0;
 367 }
 368
 369 Asset& Asset::operator=(Asset &asset)
 370 {
 371         copy_location(&asset);
 372         copy_format(&asset);
 373         return *this;
 374 }
 375
 376
 377 int Asset::equivalent(Asset &asset,
 378         int test_audio,
 379         int test_video)
 380 {
 381         int result = (!strcmp(asset.path, path) &&
 382                 format == asset.format);
 383
 384         if(test_audio && result)
 385         {
 386                 result = (channels == asset.channels &&
 387                         sample_rate == asset.sample_rate &&
 388                         bits == asset.bits &&
 389                         byte_order == asset.byte_order &&
 390                         signed_ == asset.signed_ &&
 391                         header == asset.header &&
 392                         dither == asset.dither &&
 393                         !strcmp(acodec, asset.acodec));
 394         }
 395
 396
 397         if(test_video && result)
 398         {
 399                 result = (layers == asset.layers &&
 400                         frame_rate == asset.frame_rate &&
 401                         asset.interlace_autofixoption == interlace_autofixoption &&
 402                         asset.interlace_mode    == interlace_mode &&
 403                         interlace_fixmethod     == asset.interlace_fixmethod &&
 404                         width == asset.width &&
 405                         height == asset.height &&
 406                         !strcmp(vcodec, asset.vcodec) &&
 407                         strcmp(reel_name, asset.reel_name) == 0 &&
 408                         reel_number == asset.reel_number &&
 409                         tcstart == asset.tcstart &&
 410                         tcend == asset.tcend &&
 411                         tcformat == asset.tcformat);
 412         }
 413
 414         return result;
 415 }
 416
 417 int Asset::operator==(Asset &asset)
 418 {
 419
 420         return equivalent(asset,
 421                 1,
 422                 1);
 423 }
 424
 425 int Asset::operator!=(Asset &asset)
 426 {
 427         return !(*this == asset);
 428 }
 429
 430 int Asset::test_path(const char *path)
 431 {
 432         if(!strcasecmp(this->path, path))
 433                 return 1;
 434         else
 435                 return 0;
 436 }
 437
 438 int Asset::test_plugin_title(const char *path)
 439 {
 440 }
 441
 442 int Asset::read(FileXML *file,
 443         int expand_relative)
 444 {
 445         int result = 0;
 446
 447 // Check for relative path.
 448         if(expand_relative)
 449         {
 450                 char new_path[BCTEXTLEN];
 451                 char asset_directory[BCTEXTLEN];
 452                 char input_directory[BCTEXTLEN];
 453                 FileSystem fs;
 454
 455                 strcpy(new_path, path);
 456                 fs.set_current_dir("");
 457
 458                 fs.extract_dir(asset_directory, path);
 459
 460 // No path in asset.
 461 // Take path of XML file.
 462                 if(!asset_directory[0])
 463                 {
 464                         fs.extract_dir(input_directory, file->filename);
 465
 466 // Input file has a path
 467                         if(input_directory[0])
 468                         {
 469                                 fs.join_names(path, input_directory, new_path);
 470                         }
 471                 }
 472         }
 473
 474
 475         while(!result)
 476         {
 477                 result = file->read_tag();
 478                 if(!result)
 479                 {
 480                         if(file->tag.title_is("/ASSET"))
 481                         {
 482                                 result = 1;
 483                         }
 484                         else
 485                         if(file->tag.title_is("AUDIO"))
 486                         {
 487                                 read_audio(file);
 488                         }
 489                         else
 490                         if(file->tag.title_is("AUDIO_OMIT"))
 491                         {
 492                                 read_audio(file);
 493                         }
 494                         else
 495                         if(file->tag.title_is("FORMAT"))
 496                         {
 497                                 char *string = file->tag.get_property("TYPE");
 498                                 format = File::strtoformat(string);
 499                                 use_header =
 500                                         file->tag.get_property("USE_HEADER", use_header);
 501                         }
 502                         else
 503                         if(file->tag.title_is("FOLDER"))
 504                         {
 505                                 strcpy(folder, file->read_text());
 506                         }
 507                         else
 508                         if(file->tag.title_is("VIDEO"))
 509                         {
 510                                 read_video(file);
 511                         }
 512                         else
 513                         if(file->tag.title_is("VIDEO_OMIT"))
 514                         {
 515                                 read_video(file);
 516                         }
 517                         else
 518                         if(file->tag.title_is("INDEX"))
 519                         {
 520                                 read_index(file);
 521                         }
 522                 }
 523         }
 524
 525 //printf("Asset::read 2\n");
 526         return 0;
 527 }
 528
 529 int Asset::read_audio(FileXML *file)
 530 {
 531         if(file->tag.title_is("AUDIO")) audio_data = 1;
 532         channels = file->tag.get_property("CHANNELS", 2);
 533 // This is loaded from the index file after the EDL but this
 534 // should be overridable in the EDL.
 535         if(!sample_rate) sample_rate = file->tag.get_property("RATE", 44100);
 536         bits = file->tag.get_property("BITS", 16);
 537         byte_order = file->tag.get_property("BYTE_ORDER", 1);
 538         signed_ = file->tag.get_property("SIGNED", 1);
 539         header = file->tag.get_property("HEADER", 0);
 540         dither = file->tag.get_property("DITHER", 0);
 541
 542         audio_length = file->tag.get_property("AUDIO_LENGTH", 0);
 543         acodec[0] = 0;
 544         file->tag.get_property("ACODEC", acodec);
 545
 546
 547
 548 //      ampeg_bitrate = file->tag.get_property("AMPEG_BITRATE", ampeg_bitrate);
 549 //      ampeg_derivative = file->tag.get_property("AMPEG_DERIVATIVE", ampeg_derivative);
 550 //
 551 //      vorbis_vbr = file->tag.get_property("VORBIS_VBR", vorbis_vbr);
 552 //      vorbis_min_bitrate = file->tag.get_property("VORBIS_MIN_BITRATE", vorbis_min_bitrate);
 553 //      vorbis_bitrate = file->tag.get_property("VORBIS_BITRATE", vorbis_bitrate);
 554 //      vorbis_max_bitrate = file->tag.get_property("VORBIS_MAX_BITRATE", vorbis_max_bitrate);
 555 //
 556 //      mp3_bitrate = file->tag.get_property("MP3_BITRATE", mp3_bitrate);
 557
 558         if(!video_data)
 559         {
 560                 tcstart = 0;
 561                 tcend = audio_length;
 562                 tcformat = 0;
 563         }
 564
 565         return 0;
 566 }
 567
 568 int Asset::read_video(FileXML *file)
 569 {
 570         if(file->tag.title_is("VIDEO")) video_data = 1;
 571         height = file->tag.get_property("HEIGHT", height);
 572         width = file->tag.get_property("WIDTH", width);
 573         layers = file->tag.get_property("LAYERS", layers);
 574 // This is loaded from the index file after the EDL but this
 575 // should be overridable in the EDL.
 576         if(!frame_rate) frame_rate = file->tag.get_property("FRAMERATE", frame_rate);
 577         vcodec[0] = 0;
 578         file->tag.get_property("VCODEC", vcodec);
 579
 580         video_length = file->tag.get_property("VIDEO_LENGTH", 0);
 581
 582
 583         file->tag.get_property("REEL_NAME", reel_name);
 584         reel_number = file->tag.get_property("REEL_NUMBER", reel_number);
 585         tcstart = file->tag.get_property("TCSTART", tcstart);
 586         tcend = file->tag.get_property("TCEND", tcend);
 587         tcformat = file->tag.get_property("TCFORMAT", tcformat);
 588
 589         return 0;
 590 }
 591
 592 int Asset::read_index(FileXML *file)
 593 {
 594         delete [] index_offsets;
 595         index_offsets = new int64_t[channels];
 596         delete [] index_sizes;
 597         index_sizes = new int64_t[channels];
 598         for(int i = 0; i < channels; i++)
 599         {
 600                 index_offsets[i] = 0;
 601                 index_sizes[i] = 0;
 602         }
 603
 604         int current_offset = 0;
 605         int current_size = 0;
 606         int result = 0;
 607
 608         index_zoom = file->tag.get_property("ZOOM", 1);
 609         index_bytes = file->tag.get_property("BYTES", (int64_t)0);
 610
 611         while(!result)
 612         {
 613                 result = file->read_tag();
 614                 if(!result)
 615                 {
 616                         if(file->tag.title_is("/INDEX"))
 617                         {
 618                                 result = 1;
 619                         }
 620                         else
 621                         if(file->tag.title_is("OFFSET"))
 622                         {
 623                                 if(current_offset < channels)
 624                                 {
 625                                         index_offsets[current_offset++] = file->tag.get_property("FLOAT", 0);
 626 //printf("Asset::read_index %d %d\n", current_offset - 1, index_offsets[current_offset - 1]);
 627                                 }
 628                         }
 629                         else
 630                         if(file->tag.title_is("SIZE"))
 631                         {
 632                                 if(current_size < channels)
 633                                 {
 634                                         index_sizes[current_size++] = file->tag.get_property("FLOAT", 0);
 635                                 }
 636                         }
 637                 }
 638         }
 639         return 0;
 640 }
 641
 642 int Asset::write_index(char *path, int data_bytes)
 643 {
 644         FILE *file;
 645         if(!(file = fopen(path, "wb")))
 646         {
 647 // failed to create it
 648                 printf(_("Asset::write_index Couldn't write index file %s to disk.\n"), path);
 649         }
 650         else
 651         {
 652                 FileXML xml;
 653 // Pad index start position
 654                 fwrite((char*)&(index_start), sizeof(int64_t), 1, file);
 655
 656                 index_status = INDEX_READY;
 657 // Write encoding information
 658                 write(&xml,
 659                         1,
 660                         "");
 661                 xml.write_to_file(file);
 662                 index_start = ftell(file);
 663                 fseek(file, 0, SEEK_SET);
 664 // Write index start
 665                 fwrite((char*)&(index_start), sizeof(int64_t), 1, file);
 666                 fseek(file, index_start, SEEK_SET);
 667
 668 // Write index data
 669                 fwrite(index_buffer,
 670                         data_bytes,
 671                         1,
 672                         file);
 673                 fclose(file);
 674         }
 675
 676 // Force reread of header
 677         index_status = INDEX_NOTTESTED;
 678 //      index_status = INDEX_READY;
 679         index_end = audio_length;
 680         old_index_end = 0;
 681         index_start = 0;
 682 }
 683
 684 // Output path is the path of the output file if name truncation is desired.
 685 // It is a "" if complete names should be used.
 686
 687 int Asset::write(FileXML *file,
 688         int include_index,
 689         char *output_path)
 690 {
 691         char new_path[BCTEXTLEN];
 692         char asset_directory[BCTEXTLEN];
 693         char output_directory[BCTEXTLEN];
 694         FileSystem fs;
 695
 696 // Make path relative
 697         fs.extract_dir(asset_directory, path);
 698         if(output_path && output_path[0])
 699                 fs.extract_dir(output_directory, output_path);
 700         else
 701                 output_directory[0] = 0;
 702
 703 // Asset and EDL are in same directory.  Extract just the name.
 704         if(!strcmp(asset_directory, output_directory))
 705         {
 706                 fs.extract_name(new_path, path);
 707         }
 708         else
 709         {
 710                 strcpy(new_path, path);
 711         }
 712
 713         file->tag.set_title("ASSET");
 714         file->tag.set_property("SRC", new_path);
 715         file->append_tag();
 716         file->append_newline();
 717
 718         file->tag.set_title("FOLDER");
 719         file->append_tag();
 720         file->append_text(folder);
 721         file->tag.set_title("/FOLDER");
 722         file->append_tag();
 723         file->append_newline();
 724
 725 // Write the format information
 726         file->tag.set_title("FORMAT");
 727
 728         file->tag.set_property("TYPE",
 729                 File::formattostr(format));
 730         file->tag.set_property("USE_HEADER", use_header);
 731
 732         file->append_tag();
 733         file->tag.set_title("/FORMAT");
 734         file->append_tag();
 735         file->append_newline();
 736
 737 // Requiring data to exist caused batch render to lose settings.
 738 // But the only way to know if an asset doesn't have audio or video data
 739 // is to not write the block.
 740 // So change the block name if the asset doesn't have the data.
 741         /* if(audio_data) */ write_audio(file);
 742         /* if(video_data) */ write_video(file);
 743         if(index_status == 0 && include_index) write_index(file);  // index goes after source
 744
 745         file->tag.set_title("/ASSET");
 746         file->append_tag();
 747         file->append_newline();
 748         return 0;
 749 }
 750
 751 int Asset::write_audio(FileXML *file)
 752 {
 753 // Let the reader know if the asset has the data by naming the block.
 754         if(audio_data)
 755                 file->tag.set_title("AUDIO");
 756         else
 757                 file->tag.set_title("AUDIO_OMIT");
 758 // Necessary for PCM audio
 759         file->tag.set_property("CHANNELS", channels);
 760         file->tag.set_property("RATE", sample_rate);
 761         file->tag.set_property("BITS", bits);
 762         file->tag.set_property("BYTE_ORDER", byte_order);
 763         file->tag.set_property("SIGNED", signed_);
 764         file->tag.set_property("HEADER", header);
 765         file->tag.set_property("DITHER", dither);
 766         if(acodec[0])
 767                 file->tag.set_property("ACODEC", acodec);
 768
 769         file->tag.set_property("AUDIO_LENGTH", audio_length);
 770
 771
 772
 773 // Rely on defaults operations for these.
 774
 775 //      file->tag.set_property("AMPEG_BITRATE", ampeg_bitrate);
 776 //      file->tag.set_property("AMPEG_DERIVATIVE", ampeg_derivative);
 777 //
 778 //      file->tag.set_property("VORBIS_VBR", vorbis_vbr);
 779 //      file->tag.set_property("VORBIS_MIN_BITRATE", vorbis_min_bitrate);
 780 //      file->tag.set_property("VORBIS_BITRATE", vorbis_bitrate);
 781 //      file->tag.set_property("VORBIS_MAX_BITRATE", vorbis_max_bitrate);
 782 //
 783 //      file->tag.set_property("MP3_BITRATE", mp3_bitrate);
 784 //
 785
 786
 787
 788         file->append_tag();
 789         if(audio_data)
 790           file->tag.set_title("/AUDIO");
 791         else
 792           file->tag.set_title("/AUDIO_OMIT");
 793         file->append_tag();
 794         file->append_newline();
 795         return 0;
 796 }
 797
 798 int Asset::write_video(FileXML *file)
 799 {
 800         if(video_data)
 801                 file->tag.set_title("VIDEO");
 802         else
 803                 file->tag.set_title("VIDEO_OMIT");
 804         file->tag.set_property("HEIGHT", height);
 805         file->tag.set_property("WIDTH", width);
 806         file->tag.set_property("LAYERS", layers);
 807         file->tag.set_property("FRAMERATE", frame_rate);
 808         if(vcodec[0])
 809                 file->tag.set_property("VCODEC", vcodec);
 810
 811         file->tag.set_property("VIDEO_LENGTH", video_length);
 812
 813
 814
 815         file->tag.set_property("REEL_NAME", reel_name);
 816         file->tag.set_property("REEL_NUMBER", reel_number);
 817         file->tag.set_property("TCSTART", tcstart);
 818         file->tag.set_property("TCEND", tcend);
 819         file->tag.set_property("TCFORMAT", tcformat);
 820
 821         file->append_tag();
 822         if(video_data)
 823                 file->tag.set_title("/VIDEO");
 824         else
 825                 file->tag.set_title("/VIDEO_OMIT");
 826
 827         file->append_tag();
 828         file->append_newline();
 829         return 0;
 830 }
 831
 832 int Asset::write_index(FileXML *file)
 833 {
 834         file->tag.set_title("INDEX");
 835         file->tag.set_property("ZOOM", index_zoom);
 836         file->tag.set_property("BYTES", index_bytes);
 837         file->append_tag();
 838         file->append_newline();
 839
 840         if(index_offsets)
 841         {
 842                 for(int i = 0; i < channels; i++)
 843                 {
 844                         file->tag.set_title("OFFSET");
 845                         file->tag.set_property("FLOAT", index_offsets[i]);
 846                         file->append_tag();
 847                         file->tag.set_title("/OFFSET");
 848                         file->append_tag();
 849                         file->tag.set_title("SIZE");
 850                         file->tag.set_property("FLOAT", index_sizes[i]);
 851                         file->append_tag();
 852                         file->tag.set_title("/SIZE");
 853                         file->append_tag();
 854                 }
 855         }
 856
 857         file->append_newline();
 858         file->tag.set_title("/INDEX");
 859         file->append_tag();
 860         file->append_newline();
 861         return 0;
 862 }
 863
 864
 865
 866
 867 char* Asset::construct_param(char *param, char *prefix, char *return_value)
 868 {
 869         if(prefix)
 870                 sprintf(return_value, "%s%s", prefix, param);
 871         else
 872                 strcpy(return_value, param);
 873         return return_value;
 874 }
 875
 876 #define UPDATE_DEFAULT(x, y) defaults->update(construct_param(x, prefix, string), y);
 877 #define GET_DEFAULT(x, y) defaults->get(construct_param(x, prefix, string), y);
 878
 879 void Asset::load_defaults(Defaults *defaults,
 880         char *prefix,
 881         int do_format,
 882         int do_compression,
 883         int do_path,
 884         int do_data_types,
 885         int do_bits)
 886 {
 887         char string[BCTEXTLEN];
 888
 889 // Can't save codec here because it's specific to render, record, and effect.
 890 // The codec has to be UNKNOWN for file probing to work.
 891
 892         if(do_path)
 893         {
 894                 GET_DEFAULT("PATH", path);
 895         }
 896
 897         if(do_compression)
 898         {
 899                 GET_DEFAULT("AUDIO_CODEC", acodec);
 900                 GET_DEFAULT("VIDEO_CODEC", vcodec);
 901         }
 902
 903         if(do_format)
 904         {
 905                 format = GET_DEFAULT("FORMAT", format);
 906         }
 907
 908         if(do_data_types)
 909         {
 910                 audio_data = GET_DEFAULT("AUDIO", 1);
 911                 video_data = GET_DEFAULT("VIDEO", 1);
 912         }
 913
 914         if(do_bits)
 915         {
 916                 bits = GET_DEFAULT("BITS", 16);
 917                 dither = GET_DEFAULT("DITHER", 0);
 918                 signed_ = GET_DEFAULT("SIGNED", 1);
 919                 byte_order = GET_DEFAULT("BYTE_ORDER", 1);
 920         }
 921
 922         // NOTE: this should never be saved
 923         strcpy(this->prefix, prefix ? prefix : "");
 924
 925         ampeg_bitrate = GET_DEFAULT("AMPEG_BITRATE", ampeg_bitrate);
 926         ampeg_derivative = GET_DEFAULT("AMPEG_DERIVATIVE", ampeg_derivative);
 927
 928         vorbis_vbr = GET_DEFAULT("VORBIS_VBR", vorbis_vbr);
 929         vorbis_min_bitrate = GET_DEFAULT("VORBIS_MIN_BITRATE", vorbis_min_bitrate);
 930         vorbis_bitrate = GET_DEFAULT("VORBIS_BITRATE", vorbis_bitrate);
 931         vorbis_max_bitrate = GET_DEFAULT("VORBIS_MAX_BITRATE", vorbis_max_bitrate);
 932
 933         theora_fix_bitrate = GET_DEFAULT("THEORA_FIX_BITRATE", theora_fix_bitrate);
 934         theora_bitrate = GET_DEFAULT("THEORA_BITRATE", theora_bitrate);
 935         theora_quality = GET_DEFAULT("THEORA_QUALITY", theora_quality);
 936         theora_sharpness = GET_DEFAULT("THEORA_SHARPNESS", theora_sharpness);
 937         theora_keyframe_frequency = GET_DEFAULT("THEORA_KEYFRAME_FREQUENCY", theora_keyframe_frequency);
 938         theora_keyframe_force_frequency = GET_DEFAULT("THEORA_FORCE_KEYFRAME_FEQUENCY", theora_keyframe_force_frequency);
 939
 940
 941
 942         mp3_bitrate = GET_DEFAULT("MP3_BITRATE", mp3_bitrate);
 943         mp4a_bitrate = GET_DEFAULT("MP4A_BITRATE", mp4a_bitrate);
 944         mp4a_quantqual = GET_DEFAULT("MP4A_QUANTQUAL", mp4a_quantqual);
 945
 946         jpeg_quality = GET_DEFAULT("JPEG_QUALITY", jpeg_quality);
 947         aspect_ratio = GET_DEFAULT("ASPECT_RATIO", aspect_ratio);
 948
 949         interlace_autofixoption = BC_ILACE_AUTOFIXOPTION_AUTO;
 950         interlace_mode          = BC_ILACE_MODE_UNDETECTED;
 951         interlace_fixmethod     = BC_ILACE_FIXMETHOD_UPONE;
 952
 953 // MPEG format information
 954         vmpeg_iframe_distance = GET_DEFAULT("VMPEG_IFRAME_DISTANCE", vmpeg_iframe_distance);
 955         vmpeg_pframe_distance = GET_DEFAULT("VMPEG_PFRAME_DISTANCE", vmpeg_pframe_distance);
 956         vmpeg_progressive = GET_DEFAULT("VMPEG_PROGRESSIVE", vmpeg_progressive);
 957         vmpeg_denoise = GET_DEFAULT("VMPEG_DENOISE", vmpeg_denoise);
 958         vmpeg_bitrate = GET_DEFAULT("VMPEG_BITRATE", vmpeg_bitrate);
 959         vmpeg_derivative = GET_DEFAULT("VMPEG_DERIVATIVE", vmpeg_derivative);
 960         vmpeg_quantization = GET_DEFAULT("VMPEG_QUANTIZATION", vmpeg_quantization);
 961         vmpeg_cmodel = GET_DEFAULT("VMPEG_CMODEL", vmpeg_cmodel);
 962         vmpeg_fix_bitrate = GET_DEFAULT("VMPEG_FIX_BITRATE", vmpeg_fix_bitrate);
 963         vmpeg_seq_codes = GET_DEFAULT("VMPEG_SEQ_CODES", vmpeg_seq_codes);
 964         vmpeg_preset = GET_DEFAULT("VMPEG_PRESET", vmpeg_preset);
 965         vmpeg_field_order = GET_DEFAULT("VMPEG_FIELD_ORDER", vmpeg_field_order);
 966
 967         h264_bitrate = GET_DEFAULT("H264_BITRATE", h264_bitrate);
 968         h264_quantizer = GET_DEFAULT("H264_QUANTIZER", h264_quantizer);
 969         h264_fix_bitrate = GET_DEFAULT("H264_FIX_BITRATE", h264_fix_bitrate);
 970
 971
 972         divx_bitrate = GET_DEFAULT("DIVX_BITRATE", divx_bitrate);
 973         divx_rc_period = GET_DEFAULT("DIVX_RC_PERIOD", divx_rc_period);
 974         divx_rc_reaction_ratio = GET_DEFAULT("DIVX_RC_REACTION_RATIO", divx_rc_reaction_ratio);
 975         divx_rc_reaction_period = GET_DEFAULT("DIVX_RC_REACTION_PERIOD", divx_rc_reaction_period);
 976         divx_max_key_interval = GET_DEFAULT("DIVX_MAX_KEY_INTERVAL", divx_max_key_interval);
 977         divx_max_quantizer = GET_DEFAULT("DIVX_MAX_QUANTIZER", divx_max_quantizer);
 978         divx_min_quantizer = GET_DEFAULT("DIVX_MIN_QUANTIZER", divx_min_quantizer);
 979         divx_quantizer = GET_DEFAULT("DIVX_QUANTIZER", divx_quantizer);
 980         divx_quality = GET_DEFAULT("DIVX_QUALITY", divx_quality);
 981         divx_fix_bitrate = GET_DEFAULT("DIVX_FIX_BITRATE", divx_fix_bitrate);
 982         divx_use_deblocking = GET_DEFAULT("DIVX_USE_DEBLOCKING", divx_use_deblocking);
 983
 984         theora_fix_bitrate = GET_DEFAULT("THEORA_FIX_BITRATE", theora_fix_bitrate);
 985         theora_bitrate = GET_DEFAULT("THEORA_BITRATE", theora_bitrate);
 986         theora_quality = GET_DEFAULT("THEORA_QUALITY", theora_quality);
 987         theora_sharpness = GET_DEFAULT("THEORA_SHARPNESS", theora_sharpness);
 988         theora_keyframe_frequency = GET_DEFAULT("THEORA_KEYFRAME_FREQUENCY", theora_keyframe_frequency);
 989         theora_keyframe_force_frequency = GET_DEFAULT("THEORA_FORCE_KEYFRAME_FEQUENCY", theora_keyframe_force_frequency);
 990
 991
 992         ms_bitrate = GET_DEFAULT("MS_BITRATE", ms_bitrate);
 993         ms_bitrate_tolerance = GET_DEFAULT("MS_BITRATE_TOLERANCE", ms_bitrate_tolerance);
 994         ms_interlaced = GET_DEFAULT("MS_INTERLACED", ms_interlaced);
 995         ms_quantization = GET_DEFAULT("MS_QUANTIZATION", ms_quantization);
 996         ms_gop_size = GET_DEFAULT("MS_GOP_SIZE", ms_gop_size);
 997         ms_fix_bitrate = GET_DEFAULT("MS_FIX_BITRATE", ms_fix_bitrate);
 998
 999         ac3_bitrate = GET_DEFAULT("AC3_BITRATE", ac3_bitrate);
1000
1001         png_use_alpha = GET_DEFAULT("PNG_USE_ALPHA", png_use_alpha);
1002         exr_use_alpha = GET_DEFAULT("EXR_USE_ALPHA", exr_use_alpha);
1003         exr_compression = GET_DEFAULT("EXR_COMPRESSION", exr_compression);
1004         tiff_cmodel = GET_DEFAULT("TIFF_CMODEL", tiff_cmodel);
1005         tiff_compression = GET_DEFAULT("TIFF_COMPRESSION", tiff_compression);
1006
1007         GET_DEFAULT("REEL_NAME", reel_name);
1008         reel_number = GET_DEFAULT("REEL_NUMBER", reel_number);
1009         tcstart = GET_DEFAULT("TCSTART", tcstart);
1010         tcend = GET_DEFAULT("TCEND", tcend);
1011         tcformat = GET_DEFAULT("TCFORMAT", tcformat);
1012
1013         load_format_defaults(defaults);
1014 }
1015
1016 // FUTURE: put more of the format specific variables in here
1017 void Asset::load_format_defaults(Defaults *defaults) {
1018         char temp[BCTEXTLEN];
1019         char string[BCTEXTLEN];
1020         if (! format) return;
1021
1022         // NOTE: old value is used if no init value set before GET_DEFAULT
1023
1024         // override the defaults with those for this format
1025         sprintf(temp, "FORMAT_%s_USE_PIPE", FILE_FORMAT_PREFIX(format));
1026         use_pipe = 0;
1027         use_pipe = GET_DEFAULT(temp, use_pipe);
1028
1029         sprintf(temp, "FORMAT_%s_PIPE", FILE_FORMAT_PREFIX(format));
1030         sprintf(pipe, "");
1031         GET_DEFAULT(temp, pipe);
1032
1033         sprintf(temp, "FORMAT_%s_PATH", FILE_FORMAT_PREFIX(format));
1034         sprintf(path, "");
1035         GET_DEFAULT(temp, path);
1036 }
1037
1038
1039 void Asset::save_defaults(Defaults *defaults,
1040         char *prefix,
1041         int do_format,
1042         int do_compression,
1043         int do_path,
1044         int do_data_types,
1045         int do_bits)
1046 {
1047         char string[BCTEXTLEN];
1048
1049         UPDATE_DEFAULT("PATH", path);
1050
1051         if(do_format)
1052         {
1053                 UPDATE_DEFAULT("FORMAT", format);
1054         }
1055
1056         if(do_data_types)
1057         {
1058                 UPDATE_DEFAULT("AUDIO", audio_data);
1059                 UPDATE_DEFAULT("VIDEO", video_data);
1060         }
1061
1062         if(do_compression)
1063         {
1064                 UPDATE_DEFAULT("AUDIO_CODEC", acodec);
1065                 UPDATE_DEFAULT("VIDEO_CODEC", vcodec);
1066         }
1067
1068         if(do_bits)
1069         {
1070                 UPDATE_DEFAULT("BITS", bits);
1071                 UPDATE_DEFAULT("DITHER", dither);
1072                 UPDATE_DEFAULT("SIGNED", signed_);
1073                 UPDATE_DEFAULT("BYTE_ORDER", byte_order);
1074         }
1075
1076         UPDATE_DEFAULT("AMPEG_BITRATE", ampeg_bitrate);
1077         UPDATE_DEFAULT("AMPEG_DERIVATIVE", ampeg_derivative);
1078
1079         UPDATE_DEFAULT("VORBIS_VBR", vorbis_vbr);
1080         UPDATE_DEFAULT("VORBIS_MIN_BITRATE", vorbis_min_bitrate);
1081         UPDATE_DEFAULT("VORBIS_BITRATE", vorbis_bitrate);
1082         UPDATE_DEFAULT("VORBIS_MAX_BITRATE", vorbis_max_bitrate);
1083
1084
1085         UPDATE_DEFAULT("THEORA_FIX_BITRATE", theora_fix_bitrate);
1086         UPDATE_DEFAULT("THEORA_BITRATE", theora_bitrate);
1087         UPDATE_DEFAULT("THEORA_QUALITY", theora_quality);
1088         UPDATE_DEFAULT("THEORA_SHARPNESS", theora_sharpness);
1089         UPDATE_DEFAULT("THEORA_KEYFRAME_FREQUENCY", theora_keyframe_frequency);
1090         UPDATE_DEFAULT("THEORA_FORCE_KEYFRAME_FEQUENCY", theora_keyframe_force_frequency);
1091
1092
1093
1094         UPDATE_DEFAULT("MP3_BITRATE", mp3_bitrate);
1095         UPDATE_DEFAULT("MP4A_BITRATE", mp4a_bitrate);
1096         UPDATE_DEFAULT("MP4A_QUANTQUAL", mp4a_quantqual);
1097
1098
1099
1100
1101
1102         UPDATE_DEFAULT("JPEG_QUALITY", jpeg_quality);
1103         UPDATE_DEFAULT("ASPECT_RATIO", aspect_ratio);
1104         UPDATE_DEFAULT("INTERLACE_AUTOFIXOPTION", interlace_autofixoption);
1105         UPDATE_DEFAULT("INTERLACE_MODE", interlace_mode);
1106         UPDATE_DEFAULT("INTERLACE_FIXMETHOD", interlace_fixmethod);
1107
1108
1109 // MPEG format information
1110         UPDATE_DEFAULT("VMPEG_IFRAME_DISTANCE", vmpeg_iframe_distance);
1111         UPDATE_DEFAULT("VMPEG_PFRAME_DISTANCE", vmpeg_pframe_distance);
1112         UPDATE_DEFAULT("VMPEG_PROGRESSIVE", vmpeg_progressive);
1113         UPDATE_DEFAULT("VMPEG_DENOISE", vmpeg_denoise);
1114         UPDATE_DEFAULT("VMPEG_BITRATE", vmpeg_bitrate);
1115         UPDATE_DEFAULT("VMPEG_DERIVATIVE", vmpeg_derivative);
1116         UPDATE_DEFAULT("VMPEG_QUANTIZATION", vmpeg_quantization);
1117         UPDATE_DEFAULT("VMPEG_CMODEL", vmpeg_cmodel);
1118         UPDATE_DEFAULT("VMPEG_FIX_BITRATE", vmpeg_fix_bitrate);
1119         UPDATE_DEFAULT("VMPEG_SEQ_CODES", vmpeg_seq_codes);
1120         UPDATE_DEFAULT("VMPEG_PRESET", vmpeg_preset);
1121         UPDATE_DEFAULT("VMPEG_FIELD_ORDER", vmpeg_field_order);
1122
1123         UPDATE_DEFAULT("H264_BITRATE", h264_bitrate);
1124         UPDATE_DEFAULT("H264_QUANTIZER", h264_quantizer);
1125         UPDATE_DEFAULT("H264_FIX_BITRATE", h264_fix_bitrate);
1126
1127         UPDATE_DEFAULT("DIVX_BITRATE", divx_bitrate);
1128         UPDATE_DEFAULT("DIVX_RC_PERIOD", divx_rc_period);
1129         UPDATE_DEFAULT("DIVX_RC_REACTION_RATIO", divx_rc_reaction_ratio);
1130         UPDATE_DEFAULT("DIVX_RC_REACTION_PERIOD", divx_rc_reaction_period);
1131         UPDATE_DEFAULT("DIVX_MAX_KEY_INTERVAL", divx_max_key_interval);
1132         UPDATE_DEFAULT("DIVX_MAX_QUANTIZER", divx_max_quantizer);
1133         UPDATE_DEFAULT("DIVX_MIN_QUANTIZER", divx_min_quantizer);
1134         UPDATE_DEFAULT("DIVX_QUANTIZER", divx_quantizer);
1135         UPDATE_DEFAULT("DIVX_QUALITY", divx_quality);
1136         UPDATE_DEFAULT("DIVX_FIX_BITRATE", divx_fix_bitrate);
1137         UPDATE_DEFAULT("DIVX_USE_DEBLOCKING", divx_use_deblocking);
1138
1139         UPDATE_DEFAULT("THEORA_FIX_BITRATE", theora_fix_bitrate);
1140         UPDATE_DEFAULT("THEORA_BITRATE", theora_bitrate);
1141         UPDATE_DEFAULT("THEORA_QUALITY", theora_quality);
1142         UPDATE_DEFAULT("THEORA_SHARPNESS", theora_sharpness);
1143         UPDATE_DEFAULT("THEORA_KEYFRAME_FREQUENCY", theora_keyframe_frequency);
1144         UPDATE_DEFAULT("THEORA_FORCE_KEYFRAME_FEQUENCY", theora_keyframe_force_frequency);
1145
1146
1147         UPDATE_DEFAULT("MS_BITRATE", ms_bitrate);
1148         UPDATE_DEFAULT("MS_BITRATE_TOLERANCE", ms_bitrate_tolerance);
1149         UPDATE_DEFAULT("MS_INTERLACED", ms_interlaced);
1150         UPDATE_DEFAULT("MS_QUANTIZATION", ms_quantization);
1151         UPDATE_DEFAULT("MS_GOP_SIZE", ms_gop_size);
1152         UPDATE_DEFAULT("MS_FIX_BITRATE", ms_fix_bitrate);
1153
1154         UPDATE_DEFAULT("AC3_BITRATE", ac3_bitrate);
1155
1156
1157         UPDATE_DEFAULT("PNG_USE_ALPHA", png_use_alpha);
1158         UPDATE_DEFAULT("EXR_USE_ALPHA", exr_use_alpha);
1159         UPDATE_DEFAULT("EXR_COMPRESSION", exr_compression);
1160         UPDATE_DEFAULT("TIFF_CMODEL", tiff_cmodel);
1161         UPDATE_DEFAULT("TIFF_COMPRESSION", tiff_compression);
1162
1163         UPDATE_DEFAULT("REEL_NAME", reel_name);
1164         UPDATE_DEFAULT("REEL_NUMBER", reel_number);
1165         UPDATE_DEFAULT("TCSTART", tcstart);
1166         UPDATE_DEFAULT("TCEND", tcend);
1167         UPDATE_DEFAULT("TCFORMAT", tcformat);
1168
1169         save_format_defaults(defaults);
1170 }
1171
1172
1173 // FUTURE: put more of the format specific variables in here
1174 void Asset::save_format_defaults(Defaults *defaults) {
1175         char temp[BCTEXTLEN];
1176         char string[BCTEXTLEN];
1177         if (! format) return;
1178
1179         sprintf(temp, "FORMAT_%s_USE_PIPE", FILE_FORMAT_PREFIX(format));
1180         UPDATE_DEFAULT(temp, use_pipe);
1181
1182         sprintf(temp, "FORMAT_%s_PIPE", FILE_FORMAT_PREFIX(format));
1183         UPDATE_DEFAULT(temp, pipe);
1184
1185         sprintf(temp, "FORMAT_%s_PATH", FILE_FORMAT_PREFIX(format));
1186         UPDATE_DEFAULT(temp, path);
1187 }
1188
1189
1190 int Asset::update_path(char *new_path)
1191 {
1192         strcpy(path, new_path);
1193         return 0;
1194 }
1195
1196 void Asset::update_index(Asset *asset)
1197 {
1198 //printf("Asset::update_index 1 %d\n", index_status);
1199         index_status = asset->index_status;
1200         index_zoom = asset->index_zoom;          // zoom factor of index data
1201         index_start = asset->index_start;        // byte start of index data in the index file
1202         index_bytes = asset->index_bytes;        // Total bytes in source file for comparison before rebuilding the index
1203         index_end = asset->index_end;
1204         old_index_end = asset->old_index_end;    // values for index build
1205
1206         delete [] index_offsets;
1207         delete [] index_sizes;
1208         index_offsets = 0;
1209         index_sizes = 0;
1210
1211         if(asset->index_offsets)
1212         {
1213                 index_offsets = new int64_t[asset->channels];
1214                 index_sizes = new int64_t[asset->channels];
1215
1216                 int i;
1217                 for(i = 0; i < asset->channels; i++)
1218                 {
1219 // offsets of channels in index file in floats
1220                         index_offsets[i] = asset->index_offsets[i];
1221                         index_sizes[i] = asset->index_sizes[i];
1222                 }
1223         }
1224         index_buffer = asset->index_buffer;    // pointer
1225 }
1226
1227 int Asset::set_timecode(char *tc, int format, int end)
1228 {
1229         int hr, min, sec;
1230
1231         hr = ((int) tc[0] - 48) * 10 + (int) tc[1] - 48;
1232         min = ((int) tc[3] - 48) * 10 + (int) tc[4] - 48;
1233         sec = ((int) tc[6] - 48) * 10 + (int) tc[7] - 48;
1234
1235         // This needs to be modified to handle drop-frame
1236
1237         if(end)
1238                 tcend = (int64_t) (((hr * 3600) + (min * 60) + sec) * frame_rate);
1239         else
1240                 tcstart = (int64_t) (((hr * 3600) + (min * 60) + sec) * frame_rate);
1241
1242         tcformat = format;
1243         return 0;
1244 }
1245
1246 int Asset::dump()
1247 {
1248         printf("  asset::dump\n");
1249         printf("   %p %s\n", this, path);
1250         printf("   index_status %d\n", index_status);
1251         printf("   format %d\n", format);
1252         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",
1253                 audio_data, channels, sample_rate, bits, byte_order, signed_, header, dither, acodec[0], acodec[1], acodec[2], acodec[3]);
1254         printf("   audio_length %lld\n", audio_length);
1255         printf("   video_data %d layers %d framerate %f width %d height %d vcodec %c%c%c%c aspect_ratio %f\n",
1256                 video_data, layers, frame_rate, width, height, vcodec[0], vcodec[1], vcodec[2], vcodec[3], aspect_ratio);
1257         printf("   video_length %lld \n", video_length);
1258         printf("   reel_name %s reel_number %i tcstart %d tcend %d tcf %d\n",
1259                 reel_name, reel_number, tcstart, tcend, tcformat);
1260
1261         return 0;
1262 }
1263
1264