hvirtual/cinelerra/file.C

   1 #include "asset.h"
   2 #include "bcsignals.h"
   3 #include "byteorder.h"
   4 #include "cache.inc"
   5 #include "condition.h"
   6 #include "edit.h"
   7 #include "errorbox.h"
   8 #include "file.h"
   9 #include "fileac3.h"
  10 #include "fileavi.h"
  11 #include "filebase.h"
  12 #include "fileexr.h"
  13 #include "filexml.h"
  14 #include "filejpeg.h"
  15 #include "filemov.h"
  16 #include "filempeg.h"
  17 #include "filepng.h"
  18 #include "filesndfile.h"
  19 #include "filetga.h"
  20 #include "filethread.h"
  21 #include "filetiff.h"
  22 #include "filevorbis.h"
  23 #include "formatwindow.h"
  24 #include "framecache.h"
  25 #include "language.h"
  26 #include "pluginserver.h"
  27 #include "resample.h"
  28 #include "stringfile.h"
  29 #include "vframe.h"
  30
  31
  32
  33
  34 File::File()
  35 {
  36         cpus = 1;
  37         asset = new Asset;
  38         format_completion = new Mutex("File::format_completion");
  39         write_lock = new Condition(1, "File::write_lock");
  40         frame_cache = new FrameCache;
  41         reset_parameters();
  42 }
  43
  44 File::~File()
  45 {
  46         if(getting_options)
  47         {
  48                 if(format_window) format_window->set_done(0);
  49                 format_completion->lock("File::~File");
  50                 format_completion->unlock();
  51         }
  52
  53         if(temp_frame) delete temp_frame;
  54
  55         close_file(0);
  56         reset_parameters();
  57         delete asset;
  58         delete format_completion;
  59         delete write_lock;
  60         if(frame_cache) delete frame_cache;
  61 }
  62
  63 void File::reset_parameters()
  64 {
  65         file = 0;
  66         audio_thread = 0;
  67         video_thread = 0;
  68         getting_options = 0;
  69         format_window = 0;
  70         temp_frame = 0;
  71         current_sample = 0;
  72         current_frame = 0;
  73         current_channel = 0;
  74         current_layer = 0;
  75         normalized_sample = 0;
  76         normalized_sample_rate = 0;
  77         resample = 0;
  78         use_cache = 0;
  79 }
  80
  81 int File::raise_window()
  82 {
  83         if(getting_options && format_window)
  84         {
  85                 format_window->raise_window();
  86                 format_window->flush();
  87         }
  88         return 0;
  89 }
  90
  91 void File::close_window()
  92 {
  93         if(getting_options)
  94         {
  95                 format_window->lock_window("File::close_window");
  96                 format_window->set_done(1);
  97                 format_window->unlock_window();
  98                 getting_options = 0;
  99         }
 100 }
 101
 102 int File::get_options(BC_WindowBase *parent_window,
 103         ArrayList<PluginServer*> *plugindb,
 104         Asset *asset,
 105         int audio_options,
 106         int video_options,
 107         int lock_compressor)
 108 {
 109         getting_options = 1;
 110         format_completion->lock("File::get_options");
 111         switch(asset->format)
 112         {
 113                 case FILE_AC3:
 114                         FileAC3::get_parameters(parent_window,
 115                                 asset,
 116                                 format_window,
 117                                 audio_options,
 118                                 video_options);
 119                         break;
 120                 case FILE_PCM:
 121                 case FILE_WAV:
 122                 case FILE_AU:
 123                 case FILE_AIFF:
 124                 case FILE_SND:
 125                         FileSndFile::get_parameters(parent_window,
 126                                 asset,
 127                                 format_window,
 128                                 audio_options,
 129                                 video_options);
 130                         break;
 131                 case FILE_MOV:
 132                         FileMOV::get_parameters(parent_window,
 133                                 asset,
 134                                 format_window,
 135                                 audio_options,
 136                                 video_options,
 137                                 lock_compressor);
 138                         break;
 139                 case FILE_AMPEG:
 140                 case FILE_VMPEG:
 141                         FileMPEG::get_parameters(parent_window,
 142                                 asset,
 143                                 format_window,
 144                                 audio_options,
 145                                 video_options);
 146                         break;
 147                 case FILE_AVI:
 148                         FileMOV::get_parameters(parent_window,
 149                                 asset,
 150                                 format_window,
 151                                 audio_options,
 152                                 video_options,
 153                                 lock_compressor);
 154                         break;
 155                 case FILE_AVI_LAVTOOLS:
 156                 case FILE_AVI_ARNE2:
 157                 case FILE_AVI_ARNE1:
 158                 case FILE_AVI_AVIFILE:
 159                         FileAVI::get_parameters(parent_window,
 160                                 asset,
 161                                 format_window,
 162                                 audio_options,
 163                                 video_options,
 164                                 lock_compressor);
 165                         break;
 166                 case FILE_JPEG:
 167                 case FILE_JPEG_LIST:
 168                         FileJPEG::get_parameters(parent_window,
 169                                 asset,
 170                                 format_window,
 171                                 audio_options,
 172                                 video_options);
 173                         break;
 174                 case FILE_EXR:
 175                 case FILE_EXR_LIST:
 176                         FileEXR::get_parameters(parent_window,
 177                                 asset,
 178                                 format_window,
 179                                 audio_options,
 180                                 video_options);
 181                         break;
 182                 case FILE_PNG:
 183                 case FILE_PNG_LIST:
 184                         FilePNG::get_parameters(parent_window,
 185                                 asset,
 186                                 format_window,
 187                                 audio_options,
 188                                 video_options);
 189                         break;
 190                 case FILE_TGA:
 191                 case FILE_TGA_LIST:
 192                         FileTGA::get_parameters(parent_window,
 193                                 asset,
 194                                 format_window,
 195                                 audio_options,
 196                                 video_options);
 197                         break;
 198                 case FILE_TIFF:
 199                 case FILE_TIFF_LIST:
 200                         FileTIFF::get_parameters(parent_window,
 201                                 asset,
 202                                 format_window,
 203                                 audio_options,
 204                                 video_options);
 205                         break;
 206                 case FILE_VORBIS:
 207                         FileVorbis::get_parameters(parent_window,
 208                                 asset,
 209                                 format_window,
 210                                 audio_options,
 211                                 video_options);
 212                         break;
 213                 default:
 214                         break;
 215         }
 216
 217         if(!format_window)
 218         {
 219                 ErrorBox *errorbox = new ErrorBox(PROGRAM_NAME ": Error",
 220                         parent_window->get_abs_cursor_x(1),
 221                         parent_window->get_abs_cursor_y(1));
 222                 format_window = errorbox;
 223                 getting_options = 1;
 224                 if(audio_options)
 225                         errorbox->create_objects(_("This format doesn't support audio."));
 226                 else
 227                 if(video_options)
 228                         errorbox->create_objects(_("This format doesn't support video."));
 229                 errorbox->run_window();
 230                 delete errorbox;
 231         }
 232
 233         getting_options = 0;
 234         format_window = 0;
 235         format_completion->unlock();
 236         return 0;
 237 }
 238
 239 void File::set_asset(Asset *asset)
 240 {
 241         *this->asset = *asset;
 242 }
 243
 244 int File::set_processors(int cpus)   // Set the number of cpus for certain codecs
 245 {
 246         this->cpus = cpus;
 247         return 0;
 248 }
 249
 250 int File::set_preload(int64_t size)
 251 {
 252         this->playback_preload = size;
 253         return 0;
 254 }
 255
 256 void File::set_cache_frames(int value)
 257 {
 258         use_cache = value;
 259 }
 260
 261 int File::purge_cache()
 262 {
 263         return frame_cache->delete_oldest();
 264 }
 265
 266
 267
 268
 269
 270
 271
 272
 273
 274
 275
 276 int File::open_file(ArrayList<PluginServer*> *plugindb,
 277         Asset *asset,
 278         int rd,
 279         int wr,
 280         int64_t base_samplerate,
 281         float base_framerate)
 282 {
 283         *this->asset = *asset;
 284         file = 0;
 285
 286
 287 //printf("File::open_file 1 %s %d\n", asset->path, asset->format);
 288         switch(this->asset->format)
 289         {
 290 // get the format now
 291 // If you add another format to case 0, you also need to add another case for the
 292 // file format #define.
 293                 case FILE_UNKNOWN:
 294                         FILE *stream;
 295                         if(!(stream = fopen(this->asset->path, "rb")))
 296                         {
 297 // file not found
 298                                 return 1;
 299                         }
 300
 301                         char test[16];
 302                         fread(test, 16, 1, stream);
 303
 304 //                      if(FileAVI::check_sig(this->asset))
 305 //                      {
 306 //                              fclose(stream);
 307 //                              file = new FileAVI(this->asset, this);
 308 //                      }
 309 //                      else
 310                         if(FileSndFile::check_sig(this->asset))
 311                         {
 312 // libsndfile
 313                                 fclose(stream);
 314                                 file = new FileSndFile(this->asset, this);
 315                         }
 316                         else
 317                         if(FilePNG::check_sig(this->asset))
 318                         {
 319 // PNG file
 320                                 fclose(stream);
 321                                 file = new FilePNG(this->asset, this);
 322                         }
 323                         else
 324                         if(FileJPEG::check_sig(this->asset))
 325                         {
 326 // JPEG file
 327                                 fclose(stream);
 328                                 file = new FileJPEG(this->asset, this);
 329                         }
 330                         else
 331                         if(FileEXR::check_sig(this->asset, test))
 332                         {
 333 // JPEG file
 334                                 fclose(stream);
 335                                 file = new FileEXR(this->asset, this);
 336                         }
 337                         else
 338                         if(FileTGA::check_sig(this->asset))
 339                         {
 340 // TGA file
 341                                 fclose(stream);
 342                                 file = new FileTGA(this->asset, this);
 343                         }
 344                         else
 345                         if(FileTIFF::check_sig(this->asset))
 346                         {
 347 // TIFF file
 348                                 fclose(stream);
 349                                 file = new FileTIFF(this->asset, this);
 350                         }
 351                         else
 352                         if(FileVorbis::check_sig(this->asset))
 353                         {
 354 // MPEG file
 355                                 fclose(stream);
 356                                 file = new FileVorbis(this->asset, this);
 357                         }
 358                         else
 359                         if(FileMPEG::check_sig(this->asset))
 360                         {
 361 // MPEG file
 362                                 fclose(stream);
 363                                 file = new FileMPEG(this->asset, this);
 364                         }
 365                         else
 366                         if(test[0] == '<' && test[1] == 'E' && test[2] == 'D' && test[3] == 'L' && test[4] == '>' ||
 367                                 test[0] == '<' && test[1] == 'H' && test[2] == 'T' && test[3] == 'A' && test[4] == 'L' && test[5] == '>' ||
 368                                 test[0] == '<' && test[1] == '?' && test[2] == 'x' && test[3] == 'm' && test[4] == 'l')
 369                         {
 370 // XML file
 371                                 fclose(stream);
 372                                 return FILE_IS_XML;
 373                         }    // can't load project file
 374                         else
 375                         if(FileMOV::check_sig(this->asset))
 376                         {
 377 // MOV file
 378 // should be last because quicktime lacks a magic number
 379                                 fclose(stream);
 380                                 file = new FileMOV(this->asset, this);
 381                         }
 382                         else
 383                         {
 384 // PCM file
 385                                 fclose(stream);
 386                                 return FILE_UNRECOGNIZED_CODEC;
 387                         }   // need more info
 388                         break;
 389
 390 // format already determined
 391                 case FILE_AC3:
 392                         file = new FileAC3(this->asset, this);
 393                         break;
 394
 395                 case FILE_PCM:
 396                 case FILE_WAV:
 397                 case FILE_AU:
 398                 case FILE_AIFF:
 399                 case FILE_SND:
 400 //printf("File::open_file 1\n");
 401                         file = new FileSndFile(this->asset, this);
 402                         break;
 403
 404                 case FILE_PNG:
 405                 case FILE_PNG_LIST:
 406                         file = new FilePNG(this->asset, this);
 407                         break;
 408
 409                 case FILE_JPEG:
 410                 case FILE_JPEG_LIST:
 411                         file = new FileJPEG(this->asset, this);
 412                         break;
 413
 414                 case FILE_EXR:
 415                 case FILE_EXR_LIST:
 416                         file = new FileEXR(this->asset, this);
 417                         break;
 418
 419                 case FILE_TGA_LIST:
 420                 case FILE_TGA:
 421                         file = new FileTGA(this->asset, this);
 422                         break;
 423
 424                 case FILE_TIFF:
 425                 case FILE_TIFF_LIST:
 426                         file = new FileTIFF(this->asset, this);
 427                         break;
 428
 429                 case FILE_MOV:
 430                         file = new FileMOV(this->asset, this);
 431                         break;
 432
 433                 case FILE_MPEG:
 434                 case FILE_AMPEG:
 435                 case FILE_VMPEG:
 436                         file = new FileMPEG(this->asset, this);
 437                         break;
 438
 439                 case FILE_VORBIS:
 440                         file = new FileVorbis(this->asset, this);
 441                         break;
 442
 443                 case FILE_AVI:
 444                         file = new FileMOV(this->asset, this);
 445                         break;
 446
 447                 case FILE_AVI_LAVTOOLS:
 448                 case FILE_AVI_ARNE2:
 449                 case FILE_AVI_ARNE1:
 450                 case FILE_AVI_AVIFILE:
 451                         file = new FileAVI(this->asset, this);
 452                         break;
 453
 454 // try plugins
 455                 default:
 456                         return 1;
 457                         break;
 458         }
 459 //printf("File::open_file 2\n");
 460
 461 // Reopen file with correct parser and get header.
 462         if(file->open_file(rd, wr))
 463         {
 464 //printf("File::open_file 2.5\n");
 465                 delete file;
 466                 file = 0;
 467         }
 468 //printf("File::open_file 3\n");
 469
 470
 471 // Set extra writing parameters to mandatory settings.
 472         if(file && wr)
 473         {
 474                 if(this->asset->dither) file->set_dither();
 475         }
 476
 477 // Synchronize header parameters
 478         *asset = *this->asset;
 479
 480         if(file)
 481                 return FILE_OK;
 482         else
 483                 return FILE_NOT_FOUND;
 484 }
 485
 486 int File::close_file(int ignore_thread)
 487 {
 488         if(!ignore_thread)
 489         {
 490                 stop_audio_thread();
 491                 stop_video_thread();
 492         }
 493
 494         if(file)
 495         {
 496 // The file's asset is a copy of the argument passed to open_file so the
 497 // user must copy lengths from the file's asset.
 498                 if(asset && file->wr)
 499                 {
 500                         asset->audio_length = current_sample;
 501                         asset->video_length = current_frame;
 502                 }
 503                 file->close_file();
 504                 delete file;
 505         }
 506
 507         if(resample) delete resample;
 508
 509         reset_parameters();
 510         return 0;
 511 }
 512
 513 int File::start_audio_thread(int64_t buffer_size, int ring_buffers)
 514 {
 515         audio_thread = new FileThread(this, 1, 0);
 516         audio_thread->start_writing(buffer_size, 0, ring_buffers, 0);
 517         return 0;
 518 }
 519
 520 int File::start_video_thread(int64_t buffer_size,
 521         int color_model,
 522         int ring_buffers,
 523         int compressed)
 524 {
 525         video_thread = new FileThread(this, 0, 1);
 526 //printf("File::start_video_thread 1\n");
 527         video_thread->start_writing(buffer_size,
 528                 color_model,
 529                 ring_buffers,
 530                 compressed);
 531 //printf("File::start_video_thread 2\n");
 532         return 0;
 533 }
 534
 535 int File::stop_audio_thread()
 536 {
 537 //printf("File::stop_audio_thread 1\n");
 538         if(audio_thread)
 539         {
 540                 audio_thread->stop_writing();
 541                 delete audio_thread;
 542                 audio_thread = 0;
 543         }
 544         return 0;
 545 }
 546
 547 int File::stop_video_thread()
 548 {
 549 //printf("File::stop_video_thread 1\n");
 550         if(video_thread)
 551         {
 552                 video_thread->stop_writing();
 553                 delete video_thread;
 554                 video_thread = 0;
 555         }
 556         return 0;
 557 }
 558
 559 int File::lock_read()
 560 {
 561 //      read_lock.lock();
 562         return 0;
 563 }
 564
 565 int File::unlock_read()
 566 {
 567 //      read_lock.unlock();
 568         return 0;
 569 }
 570
 571 int File::set_channel(int channel)
 572 {
 573         if(file && channel < asset->channels)
 574         {
 575                 current_channel = channel;
 576                 return 0;
 577         }
 578         else
 579                 return 1;
 580 }
 581
 582 int File::set_layer(int layer)
 583 {
 584         if(file && layer < asset->layers)
 585         {
 586                 current_layer = layer;
 587 //printf("File::set_layer 1 %d\n", layer);
 588                 return 0;
 589         }
 590         else
 591                 return 1;
 592 }
 593
 594 int64_t File::get_audio_length(int64_t base_samplerate)
 595 {
 596         int64_t result = asset->audio_length;
 597         if(result > 0)
 598         {
 599                 if(base_samplerate > 0)
 600                         return (int64_t)((double)result / asset->sample_rate * base_samplerate + 0.5);
 601                 else
 602                         return result;
 603         }
 604         else
 605                 return -1;
 606 }
 607
 608 int64_t File::get_video_length(float base_framerate)
 609 {
 610         int64_t result = asset->video_length;
 611         if(result > 0)
 612         {
 613                 if(base_framerate > 0)
 614                         return (int64_t)((double)result / asset->frame_rate * base_framerate + 0.5);
 615                 else
 616                         return result;
 617         }
 618         else
 619                 return -1;  // infinity
 620 }
 621
 622
 623 int64_t File::get_video_position(float base_framerate)
 624 {
 625         if(base_framerate > 0)
 626                 return (int64_t)((double)current_frame / asset->frame_rate * base_framerate + 0.5);
 627         else
 628                 return current_frame;
 629 }
 630
 631 int64_t File::get_audio_position(int64_t base_samplerate)
 632 {
 633         if(base_samplerate > 0)
 634         {
 635                 if(normalized_sample_rate == base_samplerate)
 636                         return normalized_sample;
 637                 else
 638                         return (int64_t)((double)current_sample /
 639                                 asset->sample_rate *
 640                                 base_samplerate +
 641                                 0.5);
 642         }
 643         else
 644                 return current_sample;
 645 }
 646
 647
 648
 649 // The base samplerate must be nonzero if the base samplerate in the calling
 650 // function is expected to change as this forces the resampler to reset.
 651
 652 int File::set_audio_position(int64_t position, float base_samplerate)
 653 {
 654         int result = 0;
 655
 656         if(!file) return 1;
 657
 658 #define REPOSITION(x, y) \
 659         (labs((x) - (y)) > 1)
 660
 661
 662
 663         if((base_samplerate && REPOSITION(normalized_sample, position)) ||
 664                 (!base_samplerate && REPOSITION(current_sample, position)))
 665         {
 666 // Can't reset resampler since one seek operation is done
 667 // for every channel to be read at the same position.
 668
 669 // Use a conditional reset for just the case of different base_samplerates
 670                 if(base_samplerate > 0)
 671                 {
 672                         if(normalized_sample_rate &&
 673                                 normalized_sample_rate != base_samplerate &&
 674                                 resample)
 675                                 resample->reset(-1);
 676
 677                         normalized_sample = position;
 678                         normalized_sample_rate = (int64_t)((base_samplerate > 0) ?
 679                                 base_samplerate :
 680                                 asset->sample_rate);
 681
 682 // Convert position to file's rate
 683                         if(base_samplerate > 0)
 684                                 current_sample = Units::round((double)position /
 685                                         base_samplerate *
 686                                         asset->sample_rate);
 687                 }
 688                 else
 689                 {
 690                         current_sample = position;
 691                         normalized_sample = Units::round((double)position /
 692                                         asset->sample_rate *
 693                                         normalized_sample_rate);
 694 // Can not set the normalized sample rate since this would reset the resampler.
 695                 }
 696
 697                 result = file->set_audio_position(current_sample);
 698
 699                 if(result)
 700                         printf("File::set_audio_position position=%d base_samplerate=%f asset=%p asset->sample_rate=%d\n",
 701                                 position, base_samplerate, asset, asset->sample_rate);
 702         }
 703
 704 //printf("File::set_audio_position %d %d %d\n", current_channel, current_sample, position);
 705
 706         return result;
 707 }
 708
 709 int File::set_video_position(int64_t position, float base_framerate)
 710 {
 711         int result = 0;
 712         if(!file) return 0;
 713
 714 // Convert to file's rate
 715         if(base_framerate > 0)
 716                 position = (int64_t)((double)position /
 717                         base_framerate *
 718                         asset->frame_rate +
 719                         0.5);
 720
 721
 722         if(current_frame != position && file)
 723         {
 724                 current_frame = position;
 725                 result = file->set_video_position(current_frame);
 726         }
 727
 728         return result;
 729 }
 730
 731 // No resampling here.
 732 int File::write_samples(double **buffer, int64_t len)
 733 {
 734         int result = 1;
 735
 736         if(file)
 737         {
 738                 write_lock->lock("File::write_samples");
 739                 result = file->write_samples(buffer, len);
 740                 current_sample += len;
 741                 normalized_sample += len;
 742                 asset->audio_length += len;
 743                 write_lock->unlock();
 744         }
 745         return result;
 746 }
 747
 748 // Can't put any cmodel abstraction here because the filebase couldn't be
 749 // parallel.
 750 int File::write_frames(VFrame ***frames, int len)
 751 {
 752 // Store the counters in temps so the filebase can choose to overwrite them.
 753         int result;
 754         int current_frame_temp = current_frame;
 755         int video_length_temp = asset->video_length;
 756         write_lock->lock("File::write_frames");
 757
 758
 759
 760
 761         result = file->write_frames(frames, len);
 762
 763
 764
 765
 766
 767         current_frame = current_frame_temp + len;
 768         asset->video_length = video_length_temp + len;
 769         write_lock->unlock();
 770         return result;
 771 }
 772
 773 int File::write_compressed_frame(VFrame *buffer)
 774 {
 775         int result = 0;
 776         write_lock->lock("File::write_compressed_frame");
 777         result = file->write_compressed_frame(buffer);
 778         current_frame++;
 779         asset->video_length++;
 780         write_lock->unlock();
 781         return result;
 782 }
 783
 784
 785 int File::write_audio_buffer(int64_t len)
 786 {
 787         int result = 0;
 788         if(audio_thread)
 789         {
 790                 result = audio_thread->write_buffer(len);
 791         }
 792         return result;
 793 }
 794
 795 int File::write_video_buffer(int64_t len)
 796 {
 797         int result = 0;
 798         if(video_thread)
 799         {
 800                 result = video_thread->write_buffer(len);
 801         }
 802
 803         return result;
 804 }
 805
 806 double** File::get_audio_buffer()
 807 {
 808         if(audio_thread) return audio_thread->get_audio_buffer();
 809         return 0;
 810 }
 811
 812 VFrame*** File::get_video_buffer()
 813 {
 814         if(video_thread) return video_thread->get_video_buffer();
 815         return 0;
 816 }
 817
 818
 819 int File::read_samples(double *buffer, int64_t len, int64_t base_samplerate)
 820 {
 821         int result = 0;
 822 //printf("File::read_samples 1\n");
 823
 824 // Load with resampling
 825         if(file)
 826         {
 827 // Resample recursively calls this with the asset sample rate
 828                 if(base_samplerate == 0) base_samplerate = asset->sample_rate;
 829
 830 //printf("File::read_samples 2 %d %d\n", base_samplerate, asset->sample_rate);
 831                 if(base_samplerate != asset->sample_rate)
 832                 {
 833 //printf("File::read_samples 3\n");
 834                         if(!resample)
 835                         {
 836 //printf("File::read_samples 4\n");
 837                                 resample = new Resample(this, asset->channels);
 838                         }
 839
 840 //printf("File::read_samples 5\n");
 841                         current_sample += resample->resample(buffer,
 842                                 len,
 843                                 asset->sample_rate,
 844                                 base_samplerate,
 845                                 current_channel,
 846                                 current_sample,
 847                                 normalized_sample);
 848 //printf("File::read_samples 6\n");
 849                 }
 850                 else
 851 // Load directly
 852                 {
 853 //printf("File::read_samples 7\n");
 854                         result = file->read_samples(buffer, len);
 855 //printf("File::read_samples 8\n");
 856                         current_sample += len;
 857                 }
 858
 859                 normalized_sample += len;
 860         }
 861         return result;
 862 }
 863
 864 int File::read_compressed_frame(VFrame *buffer)
 865 {
 866         int result = 1;
 867         if(file)
 868                 result = file->read_compressed_frame(buffer);
 869         current_frame++;
 870         return result;
 871 }
 872
 873 int64_t File::compressed_frame_size()
 874 {
 875         if(file)
 876                 return file->compressed_frame_size();
 877         else
 878                 return 0;
 879 }
 880
 881
 882
 883
 884 int File::read_frame(VFrame *frame)
 885 {
 886         if(file)
 887         {
 888                 int supported_colormodel = colormodel_supported(frame->get_color_model());
 889                 int advance_position = 1;
 890
 891
 892 // Test cache
 893                 if(use_cache &&
 894                         frame_cache->get_frame(frame,
 895                                 current_frame,
 896                                 asset->frame_rate))
 897                 {
 898 // Can't advance position if cache used.
 899                         advance_position = 0;
 900                 }
 901                 else
 902 // Need temp
 903                 if(frame->get_color_model() != BC_COMPRESSED &&
 904                         (supported_colormodel != frame->get_color_model() ||
 905                         frame->get_w() != asset->width ||
 906                         frame->get_h() != asset->height))
 907                 {
 908
 909 // Can't advance position here because it needs to be added to cache
 910                         if(temp_frame)
 911                         {
 912                                 if(!temp_frame->params_match(asset->width, asset->height, supported_colormodel))
 913                                 {
 914                                         delete temp_frame;
 915                                         temp_frame = 0;
 916                                 }
 917                         }
 918
 919                         if(!temp_frame)
 920                         {
 921                                 temp_frame = new VFrame(0,
 922                                         asset->width,
 923                                         asset->height,
 924                                         supported_colormodel);
 925                         }
 926
 927                         file->read_frame(temp_frame);
 928                         cmodel_transfer(frame->get_rows(),
 929                                 temp_frame->get_rows(),
 930                                 0,
 931                                 0,
 932                                 0,
 933                                 0,
 934                                 0,
 935                                 0,
 936                                 0,
 937                                 0,
 938                                 temp_frame->get_w(),
 939                                 temp_frame->get_h(),
 940                                 0,
 941                                 0,
 942                                 frame->get_w(),
 943                                 frame->get_h(),
 944                                 temp_frame->get_color_model(),
 945                                 frame->get_color_model(),
 946                                 0,
 947                                 temp_frame->get_w(),
 948                                 frame->get_w());
 949                 }
 950                 else
 951                 {
 952 // Can't advance position here because it needs to be added to cache
 953                         file->read_frame(frame);
 954                 }
 955
 956                 if(use_cache) frame_cache->put_frame(frame,
 957                         current_frame,
 958                         asset->frame_rate,
 959                         1);
 960
 961                 if(advance_position) current_frame++;
 962                 return 0;
 963         }
 964         else
 965                 return 1;
 966 }
 967
 968 int File::can_copy_from(Edit *edit, int64_t position, int output_w, int output_h)
 969 {
 970         if(file)
 971         {
 972                 return edit->asset->width == output_w &&
 973                         edit->asset->height == output_h &&
 974                         file->can_copy_from(edit, position);
 975         }
 976         else
 977                 return 0;
 978 }
 979
 980 // Fill in queries about formats when adding formats here.
 981
 982
 983 int File::strtoformat(char *format)
 984 {
 985         return strtoformat(0, format);
 986 }
 987
 988 int File::strtoformat(ArrayList<PluginServer*> *plugindb, char *format)
 989 {
 990         if(!strcasecmp(format, _(AC3_NAME))) return FILE_AC3;
 991         else
 992         if(!strcasecmp(format, _(WAV_NAME))) return FILE_WAV;
 993         else
 994         if(!strcasecmp(format, _(PCM_NAME))) return FILE_PCM;
 995         else
 996         if(!strcasecmp(format, _(AU_NAME))) return FILE_AU;
 997         else
 998         if(!strcasecmp(format, _(AIFF_NAME))) return FILE_AIFF;
 999         else
1000         if(!strcasecmp(format, _(SND_NAME))) return FILE_SND;
1001         else
1002         if(!strcasecmp(format, _(PNG_NAME))) return FILE_PNG;
1003         else
1004         if(!strcasecmp(format, _(PNG_LIST_NAME))) return FILE_PNG_LIST;
1005         else
1006         if(!strcasecmp(format, _(TIFF_NAME))) return FILE_TIFF;
1007         else
1008         if(!strcasecmp(format, _(TIFF_LIST_NAME))) return FILE_TIFF_LIST;
1009         else
1010         if(!strcasecmp(format, _(JPEG_NAME))) return FILE_JPEG;
1011         else
1012         if(!strcasecmp(format, _(JPEG_LIST_NAME))) return FILE_JPEG_LIST;
1013         else
1014         if(!strcasecmp(format, _(EXR_NAME))) return FILE_EXR;
1015         else
1016         if(!strcasecmp(format, _(EXR_LIST_NAME))) return FILE_EXR_LIST;
1017         else
1018         if(!strcasecmp(format, _(MPEG_NAME))) return FILE_MPEG;
1019         else
1020         if(!strcasecmp(format, _(AMPEG_NAME))) return FILE_AMPEG;
1021         else
1022         if(!strcasecmp(format, _(VMPEG_NAME))) return FILE_VMPEG;
1023         else
1024         if(!strcasecmp(format, _(TGA_NAME))) return FILE_TGA;
1025         else
1026         if(!strcasecmp(format, _(TGA_LIST_NAME))) return FILE_TGA_LIST;
1027         else
1028         if(!strcasecmp(format, _(MOV_NAME))) return FILE_MOV;
1029         else
1030         if(!strcasecmp(format, _(AVI_NAME))) return FILE_AVI;
1031         else
1032         if(!strcasecmp(format, _(AVI_LAVTOOLS_NAME))) return FILE_AVI_LAVTOOLS;
1033         else
1034         if(!strcasecmp(format, _(AVI_ARNE2_NAME))) return FILE_AVI_ARNE2;
1035         else
1036         if(!strcasecmp(format, _(AVI_ARNE1_NAME))) return FILE_AVI_ARNE1;
1037         else
1038         if(!strcasecmp(format, _(AVI_AVIFILE_NAME))) return FILE_AVI_AVIFILE;
1039         else
1040         if(!strcasecmp(format, _(VORBIS_NAME))) return FILE_VORBIS;
1041
1042         return 0;
1043 }
1044
1045 char* File::formattostr(int format)
1046 {
1047         return formattostr(0, format);
1048 }
1049
1050 char* File::formattostr(ArrayList<PluginServer*> *plugindb, int format)
1051 {
1052         switch(format)
1053         {
1054                 case FILE_AC3:
1055                         return _(AC3_NAME);
1056                         break;
1057                 case FILE_WAV:
1058                         return _(WAV_NAME);
1059                         break;
1060                 case FILE_PCM:
1061                         return _(PCM_NAME);
1062                         break;
1063                 case FILE_AU:
1064                         return _(AU_NAME);
1065                         break;
1066                 case FILE_AIFF:
1067                         return _(AIFF_NAME);
1068                         break;
1069                 case FILE_SND:
1070                         return _(SND_NAME);
1071                         break;
1072                 case FILE_PNG:
1073                         return _(PNG_NAME);
1074                         break;
1075                 case FILE_PNG_LIST:
1076                         return _(PNG_LIST_NAME);
1077                         break;
1078                 case FILE_JPEG:
1079                         return _(JPEG_NAME);
1080                         break;
1081                 case FILE_JPEG_LIST:
1082                         return _(JPEG_LIST_NAME);
1083                         break;
1084                 case FILE_EXR:
1085                         return _(EXR_NAME);
1086                         break;
1087                 case FILE_EXR_LIST:
1088                         return _(EXR_LIST_NAME);
1089                         break;
1090                 case FILE_MPEG:
1091                         return _(MPEG_NAME);
1092                         break;
1093                 case FILE_AMPEG:
1094                         return _(AMPEG_NAME);
1095                         break;
1096                 case FILE_VMPEG:
1097                         return _(VMPEG_NAME);
1098                         break;
1099                 case FILE_TGA:
1100                         return _(TGA_NAME);
1101                         break;
1102                 case FILE_TGA_LIST:
1103                         return _(TGA_LIST_NAME);
1104                         break;
1105                 case FILE_TIFF:
1106                         return _(TIFF_NAME);
1107                         break;
1108                 case FILE_TIFF_LIST:
1109                         return _(TIFF_LIST_NAME);
1110                         break;
1111                 case FILE_MOV:
1112                         return _(MOV_NAME);
1113                         break;
1114                 case FILE_AVI_LAVTOOLS:
1115                         return _(AVI_LAVTOOLS_NAME);
1116                         break;
1117                 case FILE_AVI:
1118                         return _(AVI_NAME);
1119                         break;
1120                 case FILE_AVI_ARNE2:
1121                         return _(AVI_ARNE2_NAME);
1122                         break;
1123                 case FILE_AVI_ARNE1:
1124                         return _(AVI_ARNE1_NAME);
1125                         break;
1126                 case FILE_AVI_AVIFILE:
1127                         return _(AVI_AVIFILE_NAME);
1128                         break;
1129                 case FILE_VORBIS:
1130                         return _(VORBIS_NAME);
1131                         break;
1132
1133                 default:
1134                         return _("Unknown");
1135                         break;
1136         }
1137         return "Unknown";
1138 }
1139
1140 int File::strtobits(char *bits)
1141 {
1142         if(!strcasecmp(bits, _(NAME_8BIT))) return BITSLINEAR8;
1143         if(!strcasecmp(bits, _(NAME_16BIT))) return BITSLINEAR16;
1144         if(!strcasecmp(bits, _(NAME_24BIT))) return BITSLINEAR24;
1145         if(!strcasecmp(bits, _(NAME_32BIT))) return BITSLINEAR32;
1146         if(!strcasecmp(bits, _(NAME_ULAW))) return BITSULAW;
1147         if(!strcasecmp(bits, _(NAME_ADPCM))) return BITS_ADPCM;
1148         if(!strcasecmp(bits, _(NAME_FLOAT))) return BITSFLOAT;
1149         if(!strcasecmp(bits, _(NAME_IMA4))) return BITSIMA4;
1150         return BITSLINEAR16;
1151 }
1152
1153 char* File::bitstostr(int bits)
1154 {
1155 //printf("File::bitstostr\n");
1156         switch(bits)
1157         {
1158                 case BITSLINEAR8:
1159                         return (NAME_8BIT);
1160                         break;
1161                 case BITSLINEAR16:
1162                         return (NAME_16BIT);
1163                         break;
1164                 case BITSLINEAR24:
1165                         return (NAME_24BIT);
1166                         break;
1167                 case BITSLINEAR32:
1168                         return (NAME_32BIT);
1169                         break;
1170                 case BITSULAW:
1171                         return (NAME_ULAW);
1172                         break;
1173                 case BITS_ADPCM:
1174                         return (NAME_ADPCM);
1175                         break;
1176                 case BITSFLOAT:
1177                         return (NAME_FLOAT);
1178                         break;
1179                 case BITSIMA4:
1180                         return (NAME_IMA4);
1181                         break;
1182         }
1183         return "Unknown";
1184 }
1185
1186
1187
1188 int File::str_to_byteorder(char *string)
1189 {
1190         if(!strcasecmp(string, _("Lo Hi"))) return 1;
1191         return 0;
1192 }
1193
1194 char* File::byteorder_to_str(int byte_order)
1195 {
1196         if(byte_order) return _("Lo Hi");
1197         return _("Hi Lo");
1198 }
1199
1200 int File::bytes_per_sample(int bits)
1201 {
1202         switch(bits)
1203         {
1204                 case BITSLINEAR8:
1205                         return 1;
1206                         break;
1207                 case BITSLINEAR16:
1208                         return 2;
1209                         break;
1210                 case BITSLINEAR24:
1211                         return 3;
1212                         break;
1213                 case BITSLINEAR32:
1214                         return 4;
1215                         break;
1216                 case BITSULAW:
1217                         return 1;
1218                         break;
1219                 case BITSIMA4:
1220                         return 1;
1221                         break;
1222         }
1223         return 1;
1224 }
1225
1226
1227
1228
1229
1230 int File::get_best_colormodel(int driver)
1231 {
1232         return get_best_colormodel(asset, driver);
1233 }
1234
1235 int File::get_best_colormodel(Asset *asset, int driver)
1236 {
1237         switch(asset->format)
1238         {
1239                 case FILE_MOV:
1240                         return FileMOV::get_best_colormodel(asset, driver);
1241                         break;
1242
1243                 case FILE_MPEG:
1244                         return FileMPEG::get_best_colormodel(asset, driver);
1245                         break;
1246
1247                 case FILE_JPEG:
1248                 case FILE_JPEG_LIST:
1249                         return FileJPEG::get_best_colormodel(asset, driver);
1250                         break;
1251
1252                 case FILE_EXR:
1253                 case FILE_EXR_LIST:
1254                         return FileEXR::get_best_colormodel(asset, driver);
1255                         break;
1256
1257                 case FILE_PNG:
1258                 case FILE_PNG_LIST:
1259                         return FilePNG::get_best_colormodel(asset, driver);
1260                         break;
1261
1262                 case FILE_TGA:
1263                 case FILE_TGA_LIST:
1264                         return FileTGA::get_best_colormodel(asset, driver);
1265                         break;
1266         }
1267
1268         return BC_RGB888;
1269 }
1270
1271
1272 int File::colormodel_supported(int colormodel)
1273 {
1274         if(file)
1275                 return file->colormodel_supported(colormodel);
1276
1277         return BC_RGB888;
1278 }
1279
1280
1281 int File::get_memory_usage()
1282 {
1283         int result = 0;
1284         if(temp_frame) result += temp_frame->get_data_size();
1285         if(file) result += file->get_memory_usage();
1286         result += frame_cache->get_memory_usage();
1287
1288         if(result < MIN_CACHEITEM_SIZE) result = MIN_CACHEITEM_SIZE;
1289         return result;
1290 }
1291
1292 FrameCache* File::get_frame_cache()
1293 {
1294         return frame_cache;
1295 }
1296
1297 int File::supports_video(ArrayList<PluginServer*> *plugindb, char *format)
1298 {
1299         int i, format_i = strtoformat(plugindb, format);
1300
1301         return supports_video(format_i);
1302         return 0;
1303 }
1304
1305 int File::supports_audio(ArrayList<PluginServer*> *plugindb, char *format)
1306 {
1307         int i, format_i = strtoformat(plugindb, format);
1308
1309         return supports_audio(format_i);
1310         return 0;
1311 }
1312
1313
1314 int File::supports_video(int format)
1315 {
1316 //printf("File::supports_video %d\n", format);
1317         switch(format)
1318         {
1319                 case FILE_MOV:
1320                 case FILE_JPEG:
1321                 case FILE_JPEG_LIST:
1322                 case FILE_EXR:
1323                 case FILE_EXR_LIST:
1324                 case FILE_PNG:
1325                 case FILE_PNG_LIST:
1326                 case FILE_TGA:
1327                 case FILE_TGA_LIST:
1328                 case FILE_TIFF:
1329                 case FILE_TIFF_LIST:
1330                 case FILE_VMPEG:
1331                 case FILE_AVI_LAVTOOLS:
1332                 case FILE_AVI_ARNE2:
1333                 case FILE_AVI:
1334                 case FILE_AVI_ARNE1:
1335                 case FILE_AVI_AVIFILE:
1336                         return 1;
1337                         break;
1338
1339                 default:
1340                         return 0;
1341                         break;
1342         }
1343 }
1344
1345 int File::supports_audio(int format)
1346 {
1347         switch(format)
1348         {
1349                 case FILE_AC3:
1350                 case FILE_PCM:
1351                 case FILE_WAV:
1352                 case FILE_MOV:
1353                 case FILE_AMPEG:
1354                 case FILE_VORBIS:
1355                 case FILE_AU:
1356                 case FILE_AIFF:
1357                 case FILE_SND:
1358                 case FILE_AVI:
1359                 case FILE_AVI_LAVTOOLS:
1360                 case FILE_AVI_ARNE2:
1361                 case FILE_AVI_ARNE1:
1362                 case FILE_AVI_AVIFILE:
1363                         return 1;
1364
1365                 default:
1366                         return 0;
1367                         break;
1368         }
1369 }
1370