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