cinelerra/asset.C

   1
   2 #include "asset.h"
   3 #include "assets.h"
   4 #include "bchash.h"
   5 #include "bcsignals.h"
   6 #include "edl.h"
   7 #include "file.h"
   8 #include "filesystem.h"
   9 #include "filexml.h"
  10 #include "quicktime.h"
  11 #include "interlacemodes.h"
  12
  13
  14 #include <stdio.h>
  15 #include <string.h>
  16
  17
  18 Asset::Asset()
  19  : ListItem<Asset>(), GarbageObject("Asset")
  20 {
  21         init_values();
  22 }
  23
  24 Asset::Asset(Asset &asset)
  25  : ListItem<Asset>(), GarbageObject("Asset")
  26 {
  27         init_values();
  28         *this = asset;
  29 }
  30
  31 Asset::Asset(const char *path)
  32  : ListItem<Asset>(), GarbageObject("Asset")
  33 {
  34         init_values();
  35         strcpy(this->path, path);
  36 }
  37
  38 Asset::Asset(const int plugin_type, const char *plugin_title)
  39  : ListItem<Asset>(), GarbageObject("Asset")
  40 {
  41         init_values();
  42 }
  43
  44 Asset::~Asset()
  45 {
  46         delete [] index_offsets;
  47         delete [] index_sizes;
  48 // Don't delete index buffer since it is shared with the index thread.
  49 }
  50
  51
  52 int Asset::init_values()
  53 {
  54         path[0] = 0;
  55         strcpy(folder, MEDIA_FOLDER);
  56 //      format = FILE_MOV;
  57 // Has to be unknown for file probing to succeed
  58         format = FILE_UNKNOWN;
  59         channels = 0;
  60         sample_rate = 0;
  61         bits = 0;
  62         byte_order = 0;
  63         signed_ = 0;
  64         header = 0;
  65         dither = 0;
  66         audio_data = 0;
  67         video_data = 0;
  68         audio_length = 0;
  69         video_length = 0;
  70
  71         layers = 0;
  72         frame_rate = 0;
  73         width = 0;
  74         height = 0;
  75         strcpy(vcodec, QUICKTIME_YUV2);
  76         strcpy(acodec, QUICKTIME_TWOS);
  77         jpeg_quality = 100;
  78         aspect_ratio = -1;
  79         interlace_autofixoption = BC_ILACE_AUTOFIXOPTION_AUTO;
  80         interlace_mode = BC_ILACE_MODE_UNDETECTED;
  81         interlace_fixmethod = BC_ILACE_FIXMETHOD_NONE;
  82
  83         ampeg_bitrate = 256;
  84         ampeg_derivative = 3;
  85
  86         vorbis_vbr = 0;
  87         vorbis_min_bitrate = -1;
  88         vorbis_bitrate = 128000;
  89         vorbis_max_bitrate = -1;
  90
  91         theora_fix_bitrate = 1;
  92         theora_bitrate = 860000;
  93         theora_quality = 16;
  94         theora_sharpness = 2;
  95         theora_keyframe_frequency = 64;
  96         theora_keyframe_force_frequency = 64;
  97
  98         mp3_bitrate = 256000;
  99
 100
 101         mp4a_bitrate = 256000;
 102         mp4a_quantqual = 100;
 103
 104
 105
 106 // mpeg parameters
 107         vmpeg_iframe_distance = 45;
 108         vmpeg_pframe_distance = 0;
 109         vmpeg_progressive = 0;
 110         vmpeg_denoise = 1;
 111         vmpeg_bitrate = 1000000;
 112         vmpeg_derivative = 1;
 113         vmpeg_quantization = 15;
 114         vmpeg_cmodel = 0;
 115         vmpeg_fix_bitrate = 0;
 116         vmpeg_seq_codes = 0;
 117         vmpeg_preset = 0;
 118         vmpeg_field_order = 0;
 119
 120 // Divx parameters.  BC_Hash from encore2
 121         divx_bitrate = 2000000;
 122         divx_rc_period = 50;
 123         divx_rc_reaction_ratio = 45;
 124         divx_rc_reaction_period = 10;
 125         divx_max_key_interval = 250;
 126         divx_max_quantizer = 31;
 127         divx_min_quantizer = 1;
 128         divx_quantizer = 5;
 129         divx_quality = 5;
 130         divx_fix_bitrate = 1;
 131         divx_use_deblocking = 1;
 132
 133         h264_bitrate = 2000000;
 134         h264_quantizer = 5;
 135         h264_fix_bitrate = 0;
 136
 137         ms_bitrate = 1000000;
 138         ms_bitrate_tolerance = 500000;
 139         ms_quantization = 10;
 140         ms_interlaced = 0;
 141         ms_gop_size = 45;
 142         ms_fix_bitrate = 1;
 143
 144         ac3_bitrate = 128;
 145
 146         png_use_alpha = 0;
 147         exr_use_alpha = 0;
 148         exr_compression = 0;
 149
 150         tiff_cmodel = 0;
 151         tiff_compression = 0;
 152
 153         use_header = 1;
 154
 155
 156         reset_index();
 157         id = EDL::next_id();
 158
 159         pipe[0] = 0;
 160         use_pipe = 0;
 161
 162         strcpy(prefix, "");
 163
 164         reset_timecode();
 165
 166         return 0;
 167 }
 168
 169 int Asset::reset_index()
 170 {
 171         index_status = INDEX_NOTTESTED;
 172         index_start = old_index_end = index_end = 0;
 173         index_offsets = 0;
 174         index_sizes = 0;
 175         index_zoom = 0;
 176         index_bytes = 0;
 177         index_buffer = 0;
 178         return 0;
 179 }
 180
 181 int Asset::reset_timecode()
 182 {
 183         strcpy(reel_name, "cin0000");
 184         reel_number = 0;
 185         tcstart = 0;
 186         tcend = 0;
 187         tcformat = 0;
 188
 189         return 0;
 190 }
 191
 192 void Asset::copy_from(Asset *asset, int do_index)
 193 {
 194         copy_location(asset);
 195         copy_format(asset, do_index);
 196 }
 197
 198 void Asset::copy_location(Asset *asset)
 199 {
 200         strcpy(this->path, asset->path);
 201         strcpy(this->folder, asset->folder);
 202 }
 203
 204 void Asset::copy_format(Asset *asset, int do_index)
 205 {
 206         if(do_index) update_index(asset);
 207
 208         audio_data = asset->audio_data;
 209         format = asset->format;
 210         channels = asset->channels;
 211         sample_rate = asset->sample_rate;
 212         bits = asset->bits;
 213         byte_order = asset->byte_order;
 214         signed_ = asset->signed_;
 215         header = asset->header;
 216         dither = asset->dither;
 217         mp3_bitrate = asset->mp3_bitrate;
 218         mp4a_bitrate = asset->mp4a_bitrate;
 219         mp4a_quantqual = asset->mp4a_quantqual;
 220         use_header = asset->use_header;
 221         aspect_ratio = asset->aspect_ratio;
 222         interlace_autofixoption = asset->interlace_autofixoption;
 223         interlace_mode = asset->interlace_mode;
 224         interlace_fixmethod = asset->interlace_fixmethod;
 225
 226         video_data = asset->video_data;
 227         layers = asset->layers;
 228         frame_rate = asset->frame_rate;
 229         width = asset->width;
 230         height = asset->height;
 231         strcpy(vcodec, asset->vcodec);
 232         strcpy(acodec, asset->acodec);
 233
 234         this->audio_length = asset->audio_length;
 235         this->video_length = asset->video_length;
 236
 237
 238         ampeg_bitrate = asset->ampeg_bitrate;
 239         ampeg_derivative = asset->ampeg_derivative;
 240
 241
 242         vorbis_vbr = asset->vorbis_vbr;
 243         vorbis_min_bitrate = asset->vorbis_min_bitrate;
 244         vorbis_bitrate = asset->vorbis_bitrate;
 245         vorbis_max_bitrate = asset->vorbis_max_bitrate;
 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, 1);
 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         char string[BCTEXTLEN];
 571
 572         if(file->tag.title_is("VIDEO")) video_data = 1;
 573         height = file->tag.get_property("HEIGHT", height);
 574         width = file->tag.get_property("WIDTH", width);
 575         layers = file->tag.get_property("LAYERS", layers);
 576 // This is loaded from the index file after the EDL but this
 577 // should be overridable in the EDL.
 578         if(!frame_rate) frame_rate = file->tag.get_property("FRAMERATE", frame_rate);
 579         vcodec[0] = 0;
 580         file->tag.get_property("VCODEC", vcodec);
 581
 582         video_length = file->tag.get_property("VIDEO_LENGTH", 0);
 583
 584         interlace_autofixoption = file->tag.get_property("INTERLACE_AUTOFIX",0);
 585
 586         ilacemode_to_xmltext(string, BC_ILACE_MODE_NOTINTERLACED);
 587         interlace_mode = ilacemode_from_xmltext(file->tag.get_property("INTERLACE_MODE",string), BC_ILACE_MODE_NOTINTERLACED);
 588
 589         ilacefixmethod_to_xmltext(string, BC_ILACE_FIXMETHOD_NONE);
 590         interlace_fixmethod = ilacefixmethod_from_xmltext(file->tag.get_property("INTERLACE_FIXMETHOD",string), BC_ILACE_FIXMETHOD_NONE);
 591
 592         file->tag.get_property("REEL_NAME", reel_name);
 593         reel_number = file->tag.get_property("REEL_NUMBER", reel_number);
 594         tcstart = file->tag.get_property("TCSTART", tcstart);
 595         tcend = file->tag.get_property("TCEND", tcend);
 596         tcformat = file->tag.get_property("TCFORMAT", tcformat);
 597
 598         return 0;
 599 }
 600
 601 int Asset::read_index(FileXML *file)
 602 {
 603         delete [] index_offsets;
 604         index_offsets = new int64_t[channels];
 605         delete [] index_sizes;
 606         index_sizes = new int64_t[channels];
 607         for(int i = 0; i < channels; i++)
 608         {
 609                 index_offsets[i] = 0;
 610                 index_sizes[i] = 0;
 611         }
 612
 613         int current_offset = 0;
 614         int current_size = 0;
 615         int result = 0;
 616
 617         index_zoom = file->tag.get_property("ZOOM", 1);
 618         index_bytes = file->tag.get_property("BYTES", (int64_t)0);
 619
 620         while(!result)
 621         {
 622                 result = file->read_tag();
 623                 if(!result)
 624                 {
 625                         if(file->tag.title_is("/INDEX"))
 626                         {
 627                                 result = 1;
 628                         }
 629                         else
 630                         if(file->tag.title_is("OFFSET"))
 631                         {
 632                                 if(current_offset < channels)
 633                                 {
 634                                         index_offsets[current_offset++] = file->tag.get_property("FLOAT", 0);
 635 //printf("Asset::read_index %d %d\n", current_offset - 1, index_offsets[current_offset - 1]);
 636                                 }
 637                         }
 638                         else
 639                         if(file->tag.title_is("SIZE"))
 640                         {
 641                                 if(current_size < channels)
 642                                 {
 643                                         index_sizes[current_size++] = file->tag.get_property("FLOAT", 0);
 644                                 }
 645                         }
 646                 }
 647         }
 648         return 0;
 649 }
 650
 651 int Asset::write_index(char *path, int data_bytes)
 652 {
 653         FILE *file;
 654         if(!(file = fopen(path, "wb")))
 655         {
 656 // failed to create it
 657                 printf(_("Asset::write_index Couldn't write index file %s to disk.\n"), path);
 658         }
 659         else
 660         {
 661                 FileXML xml;
 662 // Pad index start position
 663                 fwrite((char*)&(index_start), sizeof(int64_t), 1, file);
 664
 665                 index_status = INDEX_READY;
 666 // Write encoding information
 667                 write(&xml,
 668                         1,
 669                         "");
 670                 xml.write_to_file(file);
 671                 index_start = ftell(file);
 672                 fseek(file, 0, SEEK_SET);
 673 // Write index start
 674                 fwrite((char*)&(index_start), sizeof(int64_t), 1, file);
 675                 fseek(file, index_start, SEEK_SET);
 676
 677 // Write index data
 678                 fwrite(index_buffer,
 679                         data_bytes,
 680                         1,
 681                         file);
 682                 fclose(file);
 683         }
 684
 685 // Force reread of header
 686         index_status = INDEX_NOTTESTED;
 687 //      index_status = INDEX_READY;
 688         index_end = audio_length;
 689         old_index_end = 0;
 690         index_start = 0;
 691 }
 692
 693 // Output path is the path of the output file if name truncation is desired.
 694 // It is a "" if complete names should be used.
 695
 696 int Asset::write(FileXML *file,
 697         int include_index,
 698         char *output_path)
 699 {
 700         char new_path[BCTEXTLEN];
 701         char asset_directory[BCTEXTLEN];
 702         char output_directory[BCTEXTLEN];
 703         FileSystem fs;
 704
 705 // Make path relative
 706         fs.extract_dir(asset_directory, path);
 707         if(output_path && output_path[0])
 708                 fs.extract_dir(output_directory, output_path);
 709         else
 710                 output_directory[0] = 0;
 711
 712 // Asset and EDL are in same directory.  Extract just the name.
 713         if(!strcmp(asset_directory, output_directory))
 714         {
 715                 fs.extract_name(new_path, path);
 716         }
 717         else
 718         {
 719                 strcpy(new_path, path);
 720         }
 721
 722         file->tag.set_title("ASSET");
 723         file->tag.set_property("SRC", new_path);
 724         file->append_tag();
 725         file->append_newline();
 726
 727         file->tag.set_title("FOLDER");
 728         file->append_tag();
 729         file->append_text(folder);
 730         file->tag.set_title("/FOLDER");
 731         file->append_tag();
 732         file->append_newline();
 733
 734 // Write the format information
 735         file->tag.set_title("FORMAT");
 736
 737         file->tag.set_property("TYPE",
 738                 File::formattostr(format));
 739         file->tag.set_property("USE_HEADER", use_header);
 740
 741         file->append_tag();
 742         file->tag.set_title("/FORMAT");
 743         file->append_tag();
 744         file->append_newline();
 745
 746 // Requiring data to exist caused batch render to lose settings.
 747 // But the only way to know if an asset doesn't have audio or video data
 748 // is to not write the block.
 749 // So change the block name if the asset doesn't have the data.
 750         /* if(audio_data) */ write_audio(file);
 751         /* if(video_data) */ write_video(file);
 752         if(index_status == 0 && include_index) write_index(file);  // index goes after source
 753
 754         file->tag.set_title("/ASSET");
 755         file->append_tag();
 756         file->append_newline();
 757         return 0;
 758 }
 759
 760 int Asset::write_audio(FileXML *file)
 761 {
 762 // Let the reader know if the asset has the data by naming the block.
 763         if(audio_data)
 764                 file->tag.set_title("AUDIO");
 765         else
 766                 file->tag.set_title("AUDIO_OMIT");
 767 // Necessary for PCM audio
 768         file->tag.set_property("CHANNELS", channels);
 769         file->tag.set_property("RATE", sample_rate);
 770         file->tag.set_property("BITS", bits);
 771         file->tag.set_property("BYTE_ORDER", byte_order);
 772         file->tag.set_property("SIGNED", signed_);
 773         file->tag.set_property("HEADER", header);
 774         file->tag.set_property("DITHER", dither);
 775         if(acodec[0])
 776                 file->tag.set_property("ACODEC", acodec);
 777
 778         file->tag.set_property("AUDIO_LENGTH", audio_length);
 779
 780
 781
 782 // Rely on defaults operations for these.
 783
 784 //      file->tag.set_property("AMPEG_BITRATE", ampeg_bitrate);
 785 //      file->tag.set_property("AMPEG_DERIVATIVE", ampeg_derivative);
 786 //
 787 //      file->tag.set_property("VORBIS_VBR", vorbis_vbr);
 788 //      file->tag.set_property("VORBIS_MIN_BITRATE", vorbis_min_bitrate);
 789 //      file->tag.set_property("VORBIS_BITRATE", vorbis_bitrate);
 790 //      file->tag.set_property("VORBIS_MAX_BITRATE", vorbis_max_bitrate);
 791 //
 792 //      file->tag.set_property("MP3_BITRATE", mp3_bitrate);
 793 //
 794
 795
 796
 797         file->append_tag();
 798         if(audio_data)
 799           file->tag.set_title("/AUDIO");
 800         else
 801           file->tag.set_title("/AUDIO_OMIT");
 802         file->append_tag();
 803         file->append_newline();
 804         return 0;
 805 }
 806
 807 int Asset::write_video(FileXML *file)
 808 {
 809         char string[BCTEXTLEN];
 810
 811         if(video_data)
 812                 file->tag.set_title("VIDEO");
 813         else
 814                 file->tag.set_title("VIDEO_OMIT");
 815         file->tag.set_property("HEIGHT", height);
 816         file->tag.set_property("WIDTH", width);
 817         file->tag.set_property("LAYERS", layers);
 818         file->tag.set_property("FRAMERATE", frame_rate);
 819         if(vcodec[0])
 820                 file->tag.set_property("VCODEC", vcodec);
 821
 822         file->tag.set_property("VIDEO_LENGTH", video_length);
 823
 824         file->tag.set_property("INTERLACE_AUTOFIX", interlace_autofixoption);
 825
 826         ilacemode_to_xmltext(string, interlace_mode);
 827         file->tag.set_property("INTERLACE_MODE", string);
 828
 829         ilacefixmethod_to_xmltext(string, interlace_fixmethod);
 830         file->tag.set_property("INTERLACE_FIXMETHOD", string);
 831
 832
 833         file->tag.set_property("REEL_NAME", reel_name);
 834         file->tag.set_property("REEL_NUMBER", reel_number);
 835         file->tag.set_property("TCSTART", tcstart);
 836         file->tag.set_property("TCEND", tcend);
 837         file->tag.set_property("TCFORMAT", tcformat);
 838
 839         file->append_tag();
 840         if(video_data)
 841                 file->tag.set_title("/VIDEO");
 842         else
 843                 file->tag.set_title("/VIDEO_OMIT");
 844
 845         file->append_tag();
 846         file->append_newline();
 847         return 0;
 848 }
 849
 850 int Asset::write_index(FileXML *file)
 851 {
 852         file->tag.set_title("INDEX");
 853         file->tag.set_property("ZOOM", index_zoom);
 854         file->tag.set_property("BYTES", index_bytes);
 855         file->append_tag();
 856         file->append_newline();
 857
 858         if(index_offsets)
 859         {
 860                 for(int i = 0; i < channels; i++)
 861                 {
 862                         file->tag.set_title("OFFSET");
 863                         file->tag.set_property("FLOAT", index_offsets[i]);
 864                         file->append_tag();
 865                         file->tag.set_title("/OFFSET");
 866                         file->append_tag();
 867                         file->tag.set_title("SIZE");
 868                         file->tag.set_property("FLOAT", index_sizes[i]);
 869                         file->append_tag();
 870                         file->tag.set_title("/SIZE");
 871                         file->append_tag();
 872                 }
 873         }
 874
 875         file->append_newline();
 876         file->tag.set_title("/INDEX");
 877         file->append_tag();
 878         file->append_newline();
 879         return 0;
 880 }
 881
 882
 883
 884
 885 char* Asset::construct_param(char *param, char *prefix, char *return_value)
 886 {
 887         if(prefix)
 888                 sprintf(return_value, "%s%s", prefix, param);
 889         else
 890                 strcpy(return_value, param);
 891         return return_value;
 892 }
 893
 894 #define UPDATE_DEFAULT(x, y) defaults->update(construct_param(x, prefix, string), y);
 895 #define GET_DEFAULT(x, y) defaults->get(construct_param(x, prefix, string), y);
 896
 897 void Asset::load_defaults(BC_Hash *defaults,
 898         char *prefix,
 899         int do_format,
 900         int do_compression,
 901         int do_path,
 902         int do_data_types,
 903         int do_bits)
 904 {
 905         char string[BCTEXTLEN];
 906
 907 // Can't save codec here because it's specific to render, record, and effect.
 908 // The codec has to be UNKNOWN for file probing to work.
 909
 910         if(do_path)
 911         {
 912                 GET_DEFAULT("PATH", path);
 913         }
 914
 915         if(do_compression)
 916         {
 917                 GET_DEFAULT("AUDIO_CODEC", acodec);
 918                 GET_DEFAULT("VIDEO_CODEC", vcodec);
 919         }
 920
 921         if(do_format)
 922         {
 923                 format = GET_DEFAULT("FORMAT", format);
 924         }
 925
 926         if(do_data_types)
 927         {
 928                 audio_data = GET_DEFAULT("AUDIO", 1);
 929                 video_data = GET_DEFAULT("VIDEO", 1);
 930         }
 931
 932         if(do_bits)
 933         {
 934                 bits = GET_DEFAULT("BITS", 16);
 935                 dither = GET_DEFAULT("DITHER", 0);
 936                 signed_ = GET_DEFAULT("SIGNED", 1);
 937                 byte_order = GET_DEFAULT("BYTE_ORDER", 1);
 938         }
 939
 940         // NOTE: this should never be saved
 941         strcpy(this->prefix, prefix ? prefix : "");
 942
 943         ampeg_bitrate = GET_DEFAULT("AMPEG_BITRATE", ampeg_bitrate);
 944         ampeg_derivative = GET_DEFAULT("AMPEG_DERIVATIVE", ampeg_derivative);
 945
 946         vorbis_vbr = GET_DEFAULT("VORBIS_VBR", vorbis_vbr);
 947         vorbis_min_bitrate = GET_DEFAULT("VORBIS_MIN_BITRATE", vorbis_min_bitrate);
 948         vorbis_bitrate = GET_DEFAULT("VORBIS_BITRATE", vorbis_bitrate);
 949         vorbis_max_bitrate = GET_DEFAULT("VORBIS_MAX_BITRATE", vorbis_max_bitrate);
 950
 951         theora_fix_bitrate = GET_DEFAULT("THEORA_FIX_BITRATE", theora_fix_bitrate);
 952         theora_bitrate = GET_DEFAULT("THEORA_BITRATE", theora_bitrate);
 953         theora_quality = GET_DEFAULT("THEORA_QUALITY", theora_quality);
 954         theora_sharpness = GET_DEFAULT("THEORA_SHARPNESS", theora_sharpness);
 955         theora_keyframe_frequency = GET_DEFAULT("THEORA_KEYFRAME_FREQUENCY", theora_keyframe_frequency);
 956         theora_keyframe_force_frequency = GET_DEFAULT("THEORA_FORCE_KEYFRAME_FEQUENCY", theora_keyframe_force_frequency);
 957
 958
 959
 960         mp3_bitrate = GET_DEFAULT("MP3_BITRATE", mp3_bitrate);
 961         mp4a_bitrate = GET_DEFAULT("MP4A_BITRATE", mp4a_bitrate);
 962         mp4a_quantqual = GET_DEFAULT("MP4A_QUANTQUAL", mp4a_quantqual);
 963
 964         jpeg_quality = GET_DEFAULT("JPEG_QUALITY", jpeg_quality);
 965         aspect_ratio = GET_DEFAULT("ASPECT_RATIO", aspect_ratio);
 966
 967         interlace_autofixoption = BC_ILACE_AUTOFIXOPTION_AUTO;
 968         interlace_mode          = BC_ILACE_MODE_UNDETECTED;
 969         interlace_fixmethod     = BC_ILACE_FIXMETHOD_UPONE;
 970
 971 // MPEG format information
 972         vmpeg_iframe_distance = GET_DEFAULT("VMPEG_IFRAME_DISTANCE", vmpeg_iframe_distance);
 973         vmpeg_pframe_distance = GET_DEFAULT("VMPEG_PFRAME_DISTANCE", vmpeg_pframe_distance);
 974         vmpeg_progressive = GET_DEFAULT("VMPEG_PROGRESSIVE", vmpeg_progressive);
 975         vmpeg_denoise = GET_DEFAULT("VMPEG_DENOISE", vmpeg_denoise);
 976         vmpeg_bitrate = GET_DEFAULT("VMPEG_BITRATE", vmpeg_bitrate);
 977         vmpeg_derivative = GET_DEFAULT("VMPEG_DERIVATIVE", vmpeg_derivative);
 978         vmpeg_quantization = GET_DEFAULT("VMPEG_QUANTIZATION", vmpeg_quantization);
 979         vmpeg_cmodel = GET_DEFAULT("VMPEG_CMODEL", vmpeg_cmodel);
 980         vmpeg_fix_bitrate = GET_DEFAULT("VMPEG_FIX_BITRATE", vmpeg_fix_bitrate);
 981         vmpeg_seq_codes = GET_DEFAULT("VMPEG_SEQ_CODES", vmpeg_seq_codes);
 982         vmpeg_preset = GET_DEFAULT("VMPEG_PRESET", vmpeg_preset);
 983         vmpeg_field_order = GET_DEFAULT("VMPEG_FIELD_ORDER", vmpeg_field_order);
 984
 985         h264_bitrate = GET_DEFAULT("H264_BITRATE", h264_bitrate);
 986         h264_quantizer = GET_DEFAULT("H264_QUANTIZER", h264_quantizer);
 987         h264_fix_bitrate = GET_DEFAULT("H264_FIX_BITRATE", h264_fix_bitrate);
 988
 989
 990         divx_bitrate = GET_DEFAULT("DIVX_BITRATE", divx_bitrate);
 991         divx_rc_period = GET_DEFAULT("DIVX_RC_PERIOD", divx_rc_period);
 992         divx_rc_reaction_ratio = GET_DEFAULT("DIVX_RC_REACTION_RATIO", divx_rc_reaction_ratio);
 993         divx_rc_reaction_period = GET_DEFAULT("DIVX_RC_REACTION_PERIOD", divx_rc_reaction_period);
 994         divx_max_key_interval = GET_DEFAULT("DIVX_MAX_KEY_INTERVAL", divx_max_key_interval);
 995         divx_max_quantizer = GET_DEFAULT("DIVX_MAX_QUANTIZER", divx_max_quantizer);
 996         divx_min_quantizer = GET_DEFAULT("DIVX_MIN_QUANTIZER", divx_min_quantizer);
 997         divx_quantizer = GET_DEFAULT("DIVX_QUANTIZER", divx_quantizer);
 998         divx_quality = GET_DEFAULT("DIVX_QUALITY", divx_quality);
 999         divx_fix_bitrate = GET_DEFAULT("DIVX_FIX_BITRATE", divx_fix_bitrate);
1000         divx_use_deblocking = GET_DEFAULT("DIVX_USE_DEBLOCKING", divx_use_deblocking);
1001
1002         theora_fix_bitrate = GET_DEFAULT("THEORA_FIX_BITRATE", theora_fix_bitrate);
1003         theora_bitrate = GET_DEFAULT("THEORA_BITRATE", theora_bitrate);
1004         theora_quality = GET_DEFAULT("THEORA_QUALITY", theora_quality);
1005         theora_sharpness = GET_DEFAULT("THEORA_SHARPNESS", theora_sharpness);
1006         theora_keyframe_frequency = GET_DEFAULT("THEORA_KEYFRAME_FREQUENCY", theora_keyframe_frequency);
1007         theora_keyframe_force_frequency = GET_DEFAULT("THEORA_FORCE_KEYFRAME_FEQUENCY", theora_keyframe_force_frequency);
1008
1009
1010         ms_bitrate = GET_DEFAULT("MS_BITRATE", ms_bitrate);
1011         ms_bitrate_tolerance = GET_DEFAULT("MS_BITRATE_TOLERANCE", ms_bitrate_tolerance);
1012         ms_interlaced = GET_DEFAULT("MS_INTERLACED", ms_interlaced);
1013         ms_quantization = GET_DEFAULT("MS_QUANTIZATION", ms_quantization);
1014         ms_gop_size = GET_DEFAULT("MS_GOP_SIZE", ms_gop_size);
1015         ms_fix_bitrate = GET_DEFAULT("MS_FIX_BITRATE", ms_fix_bitrate);
1016
1017         ac3_bitrate = GET_DEFAULT("AC3_BITRATE", ac3_bitrate);
1018
1019         png_use_alpha = GET_DEFAULT("PNG_USE_ALPHA", png_use_alpha);
1020         exr_use_alpha = GET_DEFAULT("EXR_USE_ALPHA", exr_use_alpha);
1021         exr_compression = GET_DEFAULT("EXR_COMPRESSION", exr_compression);
1022         tiff_cmodel = GET_DEFAULT("TIFF_CMODEL", tiff_cmodel);
1023         tiff_compression = GET_DEFAULT("TIFF_COMPRESSION", tiff_compression);
1024
1025         GET_DEFAULT("REEL_NAME", reel_name);
1026         reel_number = GET_DEFAULT("REEL_NUMBER", reel_number);
1027         tcstart = GET_DEFAULT("TCSTART", tcstart);
1028         tcend = GET_DEFAULT("TCEND", tcend);
1029         tcformat = GET_DEFAULT("TCFORMAT", tcformat);
1030
1031         load_format_defaults(defaults);
1032 }
1033
1034 // FUTURE: put more of the format specific variables in here
1035 void Asset::load_format_defaults(BC_Hash *defaults) {
1036         char temp[BCTEXTLEN];
1037         char string[BCTEXTLEN];
1038         if (! format) return;
1039
1040         // NOTE: old value is used if no init value set before GET_DEFAULT
1041
1042         // override the defaults with those for this format
1043         sprintf(temp, "FORMAT_%s_USE_PIPE", FILE_FORMAT_PREFIX(format));
1044         use_pipe = 0;
1045         use_pipe = GET_DEFAULT(temp, use_pipe);
1046
1047         sprintf(temp, "FORMAT_%s_PIPE", FILE_FORMAT_PREFIX(format));
1048         sprintf(pipe, "");
1049         GET_DEFAULT(temp, pipe);
1050
1051         sprintf(temp, "FORMAT_%s_PATH", FILE_FORMAT_PREFIX(format));
1052         sprintf(path, "");
1053         GET_DEFAULT(temp, path);
1054 }
1055
1056
1057 void Asset::save_defaults(BC_Hash *defaults,
1058         char *prefix,
1059         int do_format,
1060         int do_compression,
1061         int do_path,
1062         int do_data_types,
1063         int do_bits)
1064 {
1065         char string[BCTEXTLEN];
1066
1067         UPDATE_DEFAULT("PATH", path);
1068
1069         if(do_format)
1070         {
1071                 UPDATE_DEFAULT("FORMAT", format);
1072         }
1073
1074         if(do_data_types)
1075         {
1076                 UPDATE_DEFAULT("AUDIO", audio_data);
1077                 UPDATE_DEFAULT("VIDEO", video_data);
1078         }
1079
1080         if(do_compression)
1081         {
1082                 UPDATE_DEFAULT("AUDIO_CODEC", acodec);
1083                 UPDATE_DEFAULT("VIDEO_CODEC", vcodec);
1084
1085                 UPDATE_DEFAULT("AMPEG_BITRATE", ampeg_bitrate);
1086                 UPDATE_DEFAULT("AMPEG_DERIVATIVE", ampeg_derivative);
1087
1088                 UPDATE_DEFAULT("VORBIS_VBR", vorbis_vbr);
1089                 UPDATE_DEFAULT("VORBIS_MIN_BITRATE", vorbis_min_bitrate);
1090                 UPDATE_DEFAULT("VORBIS_BITRATE", vorbis_bitrate);
1091                 UPDATE_DEFAULT("VORBIS_MAX_BITRATE", vorbis_max_bitrate);
1092
1093
1094                 UPDATE_DEFAULT("THEORA_FIX_BITRATE", theora_fix_bitrate);
1095                 UPDATE_DEFAULT("THEORA_BITRATE", theora_bitrate);
1096                 UPDATE_DEFAULT("THEORA_QUALITY", theora_quality);
1097                 UPDATE_DEFAULT("THEORA_SHARPNESS", theora_sharpness);
1098                 UPDATE_DEFAULT("THEORA_KEYFRAME_FREQUENCY", theora_keyframe_frequency);
1099                 UPDATE_DEFAULT("THEORA_FORCE_KEYFRAME_FEQUENCY", theora_keyframe_force_frequency);
1100
1101
1102
1103                 UPDATE_DEFAULT("MP3_BITRATE", mp3_bitrate);
1104                 UPDATE_DEFAULT("MP4A_BITRATE", mp4a_bitrate);
1105                 UPDATE_DEFAULT("MP4A_QUANTQUAL", mp4a_quantqual);
1106
1107
1108
1109
1110
1111                 UPDATE_DEFAULT("JPEG_QUALITY", jpeg_quality);
1112                 UPDATE_DEFAULT("ASPECT_RATIO", aspect_ratio);
1113
1114 // MPEG format information
1115                 UPDATE_DEFAULT("VMPEG_IFRAME_DISTANCE", vmpeg_iframe_distance);
1116                 UPDATE_DEFAULT("VMPEG_PFRAME_DISTANCE", vmpeg_pframe_distance);
1117                 UPDATE_DEFAULT("VMPEG_PROGRESSIVE", vmpeg_progressive);
1118                 UPDATE_DEFAULT("VMPEG_DENOISE", vmpeg_denoise);
1119                 UPDATE_DEFAULT("VMPEG_BITRATE", vmpeg_bitrate);
1120                 UPDATE_DEFAULT("VMPEG_DERIVATIVE", vmpeg_derivative);
1121                 UPDATE_DEFAULT("VMPEG_QUANTIZATION", vmpeg_quantization);
1122                 UPDATE_DEFAULT("VMPEG_CMODEL", vmpeg_cmodel);
1123                 UPDATE_DEFAULT("VMPEG_FIX_BITRATE", vmpeg_fix_bitrate);
1124                 UPDATE_DEFAULT("VMPEG_SEQ_CODES", vmpeg_seq_codes);
1125                 UPDATE_DEFAULT("VMPEG_PRESET", vmpeg_preset);
1126                 UPDATE_DEFAULT("VMPEG_FIELD_ORDER", vmpeg_field_order);
1127
1128                 UPDATE_DEFAULT("H264_BITRATE", h264_bitrate);
1129                 UPDATE_DEFAULT("H264_QUANTIZER", h264_quantizer);
1130                 UPDATE_DEFAULT("H264_FIX_BITRATE", h264_fix_bitrate);
1131
1132                 UPDATE_DEFAULT("DIVX_BITRATE", divx_bitrate);
1133                 UPDATE_DEFAULT("DIVX_RC_PERIOD", divx_rc_period);
1134                 UPDATE_DEFAULT("DIVX_RC_REACTION_RATIO", divx_rc_reaction_ratio);
1135                 UPDATE_DEFAULT("DIVX_RC_REACTION_PERIOD", divx_rc_reaction_period);
1136                 UPDATE_DEFAULT("DIVX_MAX_KEY_INTERVAL", divx_max_key_interval);
1137                 UPDATE_DEFAULT("DIVX_MAX_QUANTIZER", divx_max_quantizer);
1138                 UPDATE_DEFAULT("DIVX_MIN_QUANTIZER", divx_min_quantizer);
1139                 UPDATE_DEFAULT("DIVX_QUANTIZER", divx_quantizer);
1140                 UPDATE_DEFAULT("DIVX_QUALITY", divx_quality);
1141                 UPDATE_DEFAULT("DIVX_FIX_BITRATE", divx_fix_bitrate);
1142                 UPDATE_DEFAULT("DIVX_USE_DEBLOCKING", divx_use_deblocking);
1143
1144
1145                 UPDATE_DEFAULT("MS_BITRATE", ms_bitrate);
1146                 UPDATE_DEFAULT("MS_BITRATE_TOLERANCE", ms_bitrate_tolerance);
1147                 UPDATE_DEFAULT("MS_INTERLACED", ms_interlaced);
1148                 UPDATE_DEFAULT("MS_QUANTIZATION", ms_quantization);
1149                 UPDATE_DEFAULT("MS_GOP_SIZE", ms_gop_size);
1150                 UPDATE_DEFAULT("MS_FIX_BITRATE", ms_fix_bitrate);
1151
1152                 UPDATE_DEFAULT("AC3_BITRATE", ac3_bitrate);
1153
1154
1155                 UPDATE_DEFAULT("PNG_USE_ALPHA", png_use_alpha);
1156                 UPDATE_DEFAULT("EXR_USE_ALPHA", exr_use_alpha);
1157                 UPDATE_DEFAULT("EXR_COMPRESSION", exr_compression);
1158                 UPDATE_DEFAULT("TIFF_CMODEL", tiff_cmodel);
1159                 UPDATE_DEFAULT("TIFF_COMPRESSION", tiff_compression);
1160         }
1161
1162         if(do_bits)
1163         {
1164                 UPDATE_DEFAULT("BITS", bits);
1165                 UPDATE_DEFAULT("DITHER", dither);
1166                 UPDATE_DEFAULT("SIGNED", signed_);
1167                 UPDATE_DEFAULT("BYTE_ORDER", byte_order);
1168         }
1169
1170         UPDATE_DEFAULT("REEL_NAME", reel_name);
1171         UPDATE_DEFAULT("REEL_NUMBER", reel_number);
1172         UPDATE_DEFAULT("TCSTART", tcstart);
1173         UPDATE_DEFAULT("TCEND", tcend);
1174         UPDATE_DEFAULT("TCFORMAT", tcformat);
1175
1176         save_format_defaults(defaults);
1177 }
1178
1179
1180 // FUTURE: put more of the format specific variables in here
1181 void Asset::save_format_defaults(BC_Hash *defaults) {
1182         char temp[BCTEXTLEN];
1183         char string[BCTEXTLEN];
1184         if (! format) return;
1185
1186         sprintf(temp, "FORMAT_%s_USE_PIPE", FILE_FORMAT_PREFIX(format));
1187         UPDATE_DEFAULT(temp, use_pipe);
1188
1189         sprintf(temp, "FORMAT_%s_PIPE", FILE_FORMAT_PREFIX(format));
1190         UPDATE_DEFAULT(temp, pipe);
1191
1192         sprintf(temp, "FORMAT_%s_PATH", FILE_FORMAT_PREFIX(format));
1193         UPDATE_DEFAULT(temp, path);
1194 }
1195
1196
1197 int Asset::update_path(char *new_path)
1198 {
1199         strcpy(path, new_path);
1200         return 0;
1201 }
1202
1203 void Asset::update_index(Asset *asset)
1204 {
1205 //printf("Asset::update_index 1 %d\n", index_status);
1206         index_status = asset->index_status;
1207         index_zoom = asset->index_zoom;          // zoom factor of index data
1208         index_start = asset->index_start;        // byte start of index data in the index file
1209         index_bytes = asset->index_bytes;        // Total bytes in source file for comparison before rebuilding the index
1210         index_end = asset->index_end;
1211         old_index_end = asset->old_index_end;    // values for index build
1212
1213         delete [] index_offsets;
1214         delete [] index_sizes;
1215         index_offsets = 0;
1216         index_sizes = 0;
1217
1218         if(asset->index_offsets)
1219         {
1220                 index_offsets = new int64_t[asset->channels];
1221                 index_sizes = new int64_t[asset->channels];
1222
1223                 int i;
1224                 for(i = 0; i < asset->channels; i++)
1225                 {
1226 // offsets of channels in index file in floats
1227                         index_offsets[i] = asset->index_offsets[i];
1228                         index_sizes[i] = asset->index_sizes[i];
1229                 }
1230         }
1231         index_buffer = asset->index_buffer;    // pointer
1232 }
1233
1234 int Asset::set_timecode(char *tc, int format, int end)
1235 {
1236         int hr, min, sec;
1237
1238         hr = ((int) tc[0] - 48) * 10 + (int) tc[1] - 48;
1239         min = ((int) tc[3] - 48) * 10 + (int) tc[4] - 48;
1240         sec = ((int) tc[6] - 48) * 10 + (int) tc[7] - 48;
1241
1242         // This needs to be modified to handle drop-frame
1243
1244         if(end)
1245                 tcend = (int64_t) (((hr * 3600) + (min * 60) + sec) * frame_rate);
1246         else
1247                 tcstart = (int64_t) (((hr * 3600) + (min * 60) + sec) * frame_rate);
1248
1249         tcformat = format;
1250         return 0;
1251 }
1252
1253 int Asset::dump()
1254 {
1255         printf("  asset::dump\n");
1256         printf("   %p %s\n", this, path);
1257         printf("   index_status %d\n", index_status);
1258         printf("   format %d\n", format);
1259         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",
1260                 audio_data, channels, sample_rate, bits, byte_order, signed_, header, dither, acodec[0], acodec[1], acodec[2], acodec[3]);
1261         printf("   audio_length %lld\n", audio_length);
1262         char string[BCTEXTLEN];
1263         ilacemode_to_xmltext(string, interlace_mode);
1264         printf("   video_data %d layers %d framerate %f width %d height %d vcodec %c%c%c%c aspect_ratio %f interlace_mode %s\n",
1265                video_data, layers, frame_rate, width, height, vcodec[0], vcodec[1], vcodec[2], vcodec[3], aspect_ratio, string);
1266         printf("   video_length %lld \n", video_length);
1267         printf("   reel_name %s reel_number %i tcstart %d tcend %d tcf %d\n",
1268                 reel_name, reel_number, tcstart, tcend, tcformat);
1269
1270         return 0;
1271 }
1272
1273