cinelerra/asset.C

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