cinelerra-5.1/cinelerra/file.C

   1 /*
   2  * CINELERRA
   3  * Copyright (C) 2010 Adam Williams <broadcast at earthling dot net>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  *
  19  */
  20
  21 #include <stdio.h>
  22 #include <stdint.h>
  23 #include <stdlib.h>
  24 #include <unistd.h>
  25 #include <string.h>
  26 #include <stdarg.h>
  27 #include <ctype.h>
  28 #include <limits.h>
  29 // work arounds (centos)
  30 #include <lzma.h>
  31 #ifndef INT64_MAX
  32 #define INT64_MAX 9223372036854775807LL
  33 #endif
  34
  35 #include "asset.h"
  36 #include "bchash.h"
  37 #include "bcsignals.h"
  38 #include "byteorder.h"
  39 #include "cache.inc"
  40 #include "condition.h"
  41 #include "errorbox.h"
  42 #include "fileac3.h"
  43 #include "filebase.h"
  44 #include "filecr2.h"
  45 #include "filedb.h"
  46 #include "filedv.h"
  47 #include "fileexr.h"
  48 #include "fileffmpeg.h"
  49 #include "fileflac.h"
  50 #include "filegif.h"
  51 #include "file.h"
  52 #include "filejpeg.h"
  53 #include "filempeg.h"
  54 #undef HAVE_STDLIB_H // automake conflict
  55 #include "fileogg.h"
  56 #include "filepng.h"
  57 #include "filescene.h"
  58 #include "filesndfile.h"
  59 #include "filetga.h"
  60 #include "filethread.h"
  61 #include "filetiff.h"
  62 #include "filevorbis.h"
  63 #include "filexml.h"
  64 #include "formatwindow.h"
  65 #include "formattools.h"
  66 #include "framecache.h"
  67 #include "language.h"
  68 #include "mainprogress.inc"
  69 #include "mutex.h"
  70 #include "mwindow.h"
  71 #include "packagingengine.h"
  72 #include "pluginserver.h"
  73 #include "preferences.h"
  74 #include "probeprefs.h"
  75 #include "samples.h"
  76 #include "vframe.h"
  77
  78 //suppress noref warning
  79 void *vorbis0_ov_callbacks[] = {
  80  &OV_CALLBACKS_DEFAULT, &OV_CALLBACKS_NOCLOSE,
  81  &OV_CALLBACKS_STREAMONLY, &OV_CALLBACKS_STREAMONLY_NOCLOSE,
  82 };
  83
  84 File::File()
  85 {
  86         cpus = 1;
  87         asset = new Asset;
  88         format_completion = new Condition(1, "File::format_completion");
  89         write_lock = new Condition(1, "File::write_lock");
  90         frame_cache = new FrameCache;
  91         reset_parameters();
  92 }
  93
  94 File::~File()
  95 {
  96         if(getting_options)
  97         {
  98                 if(format_window) format_window->set_done(0);
  99                 format_completion->lock("File::~File");
 100                 format_completion->unlock();
 101         }
 102
 103         if(temp_frame) delete temp_frame;
 104
 105
 106         close_file(0);
 107
 108         asset->Garbage::remove_user();
 109         delete format_completion;
 110         delete write_lock;
 111         delete frame_cache;
 112 }
 113
 114 void File::reset_parameters()
 115 {
 116         file = 0;
 117         audio_thread = 0;
 118         video_thread = 0;
 119         getting_options = 0;
 120         format_window = 0;
 121         temp_frame = 0;
 122         current_sample = 0;
 123         current_frame = 0;
 124         current_channel = 0;
 125         current_program = 0;
 126         current_layer = 0;
 127         normalized_sample = 0;
 128         use_cache = 0;
 129         preferences = 0;
 130         playback_subtitle = -1;
 131         interpolate_raw = 1;
 132
 133
 134         temp_samples_buffer = 0;
 135         temp_frame_buffer = 0;
 136         current_frame_buffer = 0;
 137         audio_ring_buffers = 0;
 138         video_ring_buffers = 0;
 139         video_buffer_size = 0;
 140 }
 141
 142 int File::raise_window()
 143 {
 144         if(getting_options && format_window)
 145         {
 146                 format_window->raise_window();
 147                 format_window->flush();
 148         }
 149         return 0;
 150 }
 151
 152 void File::close_window()
 153 {
 154         if(getting_options)
 155         {
 156                 format_window->lock_window("File::close_window");
 157                 format_window->set_done(1);
 158                 format_window->unlock_window();
 159                 getting_options = 0;
 160         }
 161 }
 162
 163 int File::get_options(FormatTools *format,
 164         int audio_options, int video_options)
 165 {
 166         BC_WindowBase *parent_window = format->window;
 167         //ArrayList<PluginServer*> *plugindb = format->plugindb;
 168         Asset *asset = format->asset;
 169
 170         getting_options = 1;
 171         format_completion->lock("File::get_options");
 172         switch(asset->format)
 173         {
 174                 case FILE_AC3:
 175                         FileAC3::get_parameters(parent_window,
 176                                 asset,
 177                                 format_window,
 178                                 audio_options,
 179                                 video_options);
 180                         break;
 181 #ifdef HAVE_DV
 182                 case FILE_RAWDV:
 183                         FileDV::get_parameters(parent_window,
 184                                 asset,
 185                                 format_window,
 186                                 audio_options,
 187                                 video_options);
 188                         break;
 189 #endif
 190                 case FILE_PCM:
 191                 case FILE_WAV:
 192                 case FILE_AU:
 193                 case FILE_AIFF:
 194                 case FILE_SND:
 195                         FileSndFile::get_parameters(parent_window,
 196                                 asset,
 197                                 format_window,
 198                                 audio_options,
 199                                 video_options);
 200                         break;
 201                 case FILE_FFMPEG:
 202                         FileFFMPEG::get_parameters(parent_window,
 203                                 asset,
 204                                 format_window,
 205                                 audio_options,
 206                                 video_options);
 207                         break;
 208                 case FILE_AMPEG:
 209                 case FILE_VMPEG:
 210                         FileMPEG::get_parameters(parent_window,
 211                                 asset,
 212                                 format_window,
 213                                 audio_options,
 214                                 video_options);
 215                         break;
 216                 case FILE_JPEG:
 217                 case FILE_JPEG_LIST:
 218                         FileJPEG::get_parameters(parent_window,
 219                                 asset,
 220                                 format_window,
 221                                 audio_options,
 222                                 video_options);
 223                         break;
 224 #ifdef HAVE_OPENEXR
 225                 case FILE_EXR:
 226                 case FILE_EXR_LIST:
 227                         FileEXR::get_parameters(parent_window,
 228                                 asset,
 229                                 format_window,
 230                                 audio_options,
 231                                 video_options);
 232                         break;
 233 #endif
 234                 case FILE_FLAC:
 235                         FileFLAC::get_parameters(parent_window,
 236                                 asset,
 237                                 format_window,
 238                                 audio_options,
 239                                 video_options);
 240                         break;
 241                 case FILE_PNG:
 242                 case FILE_PNG_LIST:
 243                         FilePNG::get_parameters(parent_window,
 244                                 asset,
 245                                 format_window,
 246                                 audio_options,
 247                                 video_options);
 248                         break;
 249                 case FILE_TGA:
 250                 case FILE_TGA_LIST:
 251                         FileTGA::get_parameters(parent_window,
 252                                 asset,
 253                                 format_window,
 254                                 audio_options,
 255                                 video_options);
 256                         break;
 257                 case FILE_TIFF:
 258                 case FILE_TIFF_LIST:
 259                         FileTIFF::get_parameters(parent_window,
 260                                 asset,
 261                                 format_window,
 262                                 audio_options,
 263                                 video_options);
 264                         break;
 265                 case FILE_OGG:
 266                         FileOGG::get_parameters(parent_window,
 267                                 asset,
 268                                 format_window,
 269                                 audio_options,
 270                                 video_options);
 271                         break;
 272                 default:
 273                         break;
 274         }
 275
 276         if(!format_window)
 277         {
 278                 ErrorBox *errorbox = new ErrorBox(_(PROGRAM_NAME ": Error"),
 279                         parent_window->get_abs_cursor_x(1),
 280                         parent_window->get_abs_cursor_y(1));
 281                 format_window = errorbox;
 282                 getting_options = 1;
 283                 if(audio_options)
 284                         errorbox->create_objects(_("This format doesn't support audio."));
 285                 else
 286                 if(video_options)
 287                         errorbox->create_objects(_("This format doesn't support video."));
 288                 errorbox->run_window();
 289                 delete errorbox;
 290         }
 291
 292         getting_options = 0;
 293         format_window = 0;
 294         format_completion->unlock();
 295         return 0;
 296 }
 297
 298
 299
 300
 301
 302
 303
 304
 305
 306
 307 int File::set_processors(int cpus)   // Set the number of cpus for certain codecs
 308 {
 309         if( cpus > 8 )          // mpegvideo max_threads = 16, more causes errs
 310                 cpus = 8;       //  8 cpus ought to decode just about anything
 311 // Set all instances so gets work.
 312         this->cpus = cpus;
 313
 314         return 0;
 315 }
 316
 317 int File::set_preload(int64_t size)
 318 {
 319         this->playback_preload = size;
 320         return 0;
 321 }
 322
 323 void File::set_subtitle(int value)
 324 {
 325         this->playback_subtitle = value;
 326         if( file ) file->set_subtitle(value);
 327 }
 328
 329 void File::set_interpolate_raw(int value)
 330 {
 331         this->interpolate_raw = value;
 332 }
 333
 334 void File::set_white_balance_raw(int value)
 335 {
 336         this->white_balance_raw = value;
 337 }
 338
 339
 340 void File::set_cache_frames(int value)
 341 {
 342 // caching only done locally
 343         if(!video_thread)
 344                 use_cache = value;
 345 }
 346
 347 int File::purge_cache()
 348 {
 349 // caching only done locally
 350         int result = 0;
 351         if( frame_cache->cache_items() > 0 )
 352         {
 353                 frame_cache->remove_all();
 354                 result = 1;
 355         }
 356         return result;
 357 }
 358
 359 int File::delete_oldest()
 360 {
 361 // caching only done locally
 362         return frame_cache->delete_oldest();
 363 }
 364
 365 // file driver in order of probe precidence
 366 //  can be reordered in preferences->interface
 367 const char *File::default_probes[] = {
 368         "FFMPEG_Early",
 369         "Scene",
 370         "DB",
 371 #ifdef HAVE_DV
 372         "DV",
 373 #endif
 374         "SndFile",
 375         "PNG",
 376         "JPEG",
 377         "GIF",
 378 #ifdef HAVE_OPENEXR
 379         "EXR",
 380 #endif
 381         "FLAC",
 382         "CR2",
 383         "TGA",
 384         "TIFF",
 385         "OGG",
 386         "Vorbis",
 387         "MPEG",
 388         "EDL",
 389         "FFMPEG_Late",
 390 };
 391 const int File::nb_probes =
 392         sizeof(File::default_probes)/sizeof(File::default_probes[0]);
 393
 394
 395 int File::probe()
 396 {
 397         FILE *fp = fopen(this->asset->path, "rb");
 398         if( !fp ) return FILE_NOT_FOUND;
 399         char data[16];
 400         memset(data,0,sizeof(data));
 401         int ret = fread(data, 1, 16, fp);
 402         fclose(fp);
 403         if( !ret ) return FILE_NOT_FOUND;
 404
 405         for( int i=0; i<preferences->file_probes.size(); ++i ) {
 406                 ProbePref *pref = preferences->file_probes[i];
 407                 if( !pref->armed ) continue;
 408                 if( !strncmp(pref->name,"FFMPEG",6) ) { // FFMPEG Early/Late
 409                         if( !FileFFMPEG::check_sig(this->asset) ) continue;
 410                         file = new FileFFMPEG(this->asset, this);
 411                         return FILE_OK;
 412                 }
 413                 if( !strcmp(pref->name,"DB") ) { // MediaDB
 414                         if( !FileDB::check_sig(this->asset) ) continue;
 415                         file = new FileDB(this->asset, this);
 416                         return FILE_OK;
 417                 }
 418                 if( !strcmp(pref->name,"Scene") ) { // scene file
 419                         if( !FileScene::check_sig(this->asset, data)) continue;
 420                         file = new FileScene(this->asset, this);
 421                         return FILE_OK;
 422                 }
 423 #ifdef HAVE_DV
 424                 if( !strcmp(pref->name,"DV") ) { // libdv
 425                         if( !FileDV::check_sig(this->asset) ) continue;
 426                         file = new FileDV(this->asset, this);
 427                         return FILE_OK;
 428                 }
 429 #endif
 430                 if( !strcmp(pref->name,"SndFile") ) { // libsndfile
 431                         if( !FileSndFile::check_sig(this->asset) ) continue;
 432                         file = new FileSndFile(this->asset, this);
 433                         return FILE_OK;
 434                 }
 435                 if( !strcmp(pref->name,"PNG") ) { // PNG file
 436                         if( !FilePNG::check_sig(this->asset) ) continue;
 437                         file = new FilePNG(this->asset, this);
 438                         return FILE_OK;
 439                 }
 440                 if( !strcmp(pref->name,"JPEG") ) { // JPEG file
 441                         if( !FileJPEG::check_sig(this->asset) ) continue;
 442                         file = new FileJPEG(this->asset, this);
 443                         return FILE_OK;
 444                 }
 445                 if( !strcmp(pref->name,"GIF") ) { // GIF file
 446                         if( !FileGIF::check_sig(this->asset)) continue;
 447                         file = new FileGIF(this->asset, this);
 448                         return FILE_OK;
 449                 }
 450 #ifdef HAVE_EXR
 451                 if( !strcmp(pref->name,"EXR") ) { // EXR file
 452                         if( !FileEXR::check_sig(this->asset, data)) continue;
 453                         file = new FileEXR(this->asset, this);
 454                         return FILE_OK;
 455                 }
 456 #endif
 457                 if( !strcmp(pref->name,"FLAC") ) { // FLAC file
 458                         if( !FileFLAC::check_sig(this->asset, data)) continue;
 459                         file = new FileFLAC(this->asset, this);
 460                         return FILE_OK;
 461                 }
 462                 if( !strcmp(pref->name,"CR2") ) { // CR2 file
 463                         if( !FileCR2::check_sig(this->asset)) continue;
 464                         file = new FileCR2(this->asset, this);
 465                         return FILE_OK;
 466                 }
 467                 if( !strcmp(pref->name,"TGA") ) { // TGA file
 468                         if( !FileTGA::check_sig(this->asset) ) continue;
 469                         file = new FileTGA(this->asset, this);
 470                         return FILE_OK;
 471                 }
 472                 if( !strcmp(pref->name,"TIFF") ) { // TIFF file
 473                         if( !FileTIFF::check_sig(this->asset) ) continue;
 474                         file = new FileTIFF(this->asset, this);
 475                         return FILE_OK;
 476                 }
 477                 if( !strcmp(pref->name,"OGG") ) { // OGG file
 478                         if( !FileOGG::check_sig(this->asset) ) continue;
 479                         file = new FileOGG(this->asset, this);
 480                         return FILE_OK;
 481                 }
 482                 if( !strcmp(pref->name,"Vorbis") ) { // VorbisFile file
 483                         if( !FileVorbis::check_sig(this->asset) ) continue;
 484                         file = new FileVorbis(this->asset, this);
 485                         return FILE_OK;
 486                 }
 487                 if( !strcmp(pref->name,"MPEG") ) { // MPEG file
 488                         if( !FileMPEG::check_sig(this->asset) ) continue;
 489                         file = new FileMPEG(this->asset, this);
 490                         return FILE_OK;
 491                 }
 492                 if( !strcmp(pref->name,"EDL") ) { // XML file
 493                         if( data[0] != '<' ) continue;
 494                         if( !strncmp(&data[1],"EDL>",4) ||
 495                             !strncmp(&data[1],"HTAL>",5) ||
 496                             !strncmp(&data[1],"?xml",4) )
 497                                 return FILE_IS_XML;
 498                 }
 499         }
 500         return FILE_UNRECOGNIZED_CODEC; // maybe PCM file ?
 501 }
 502
 503 int File::open_file(Preferences *preferences,
 504         Asset *asset,
 505         int rd,
 506         int wr)
 507 {
 508         const int debug = 0;
 509
 510         this->preferences = preferences;
 511         this->asset->copy_from(asset, 1);
 512         this->rd = rd;
 513         this->wr = wr;
 514         file = 0;
 515
 516         if(debug) printf("File::open_file %d\n", __LINE__);
 517
 518         if(debug) printf("File::open_file %p %d\n", this, __LINE__);
 519
 520         switch(this->asset->format) {
 521 // get the format now
 522 // If you add another format to case 0, you also need to add another case for the
 523 // file format #define.
 524         case FILE_UNKNOWN: {
 525                 int ret = probe();
 526                 if( ret != FILE_OK ) return ret;
 527                 break; }
 528 // format already determined
 529         case FILE_AC3:
 530                 file = new FileAC3(this->asset, this);
 531                 break;
 532
 533         case FILE_SCENE:
 534                 file = new FileScene(this->asset, this);
 535                 break;
 536
 537         case FILE_FFMPEG:
 538                 file = new FileFFMPEG(this->asset, this);
 539                 break;
 540
 541         case FILE_PCM:
 542         case FILE_WAV:
 543         case FILE_AU:
 544         case FILE_AIFF:
 545         case FILE_SND:
 546 //printf("File::open_file 1\n");
 547                 file = new FileSndFile(this->asset, this);
 548                 break;
 549
 550         case FILE_PNG:
 551         case FILE_PNG_LIST:
 552                 file = new FilePNG(this->asset, this);
 553                 break;
 554
 555         case FILE_JPEG:
 556         case FILE_JPEG_LIST:
 557                 file = new FileJPEG(this->asset, this);
 558                 break;
 559
 560         case FILE_GIF:
 561         case FILE_GIF_LIST:
 562                 file = new FileGIF(this->asset, this);
 563                 break;
 564 #ifdef HAVE_OPENEXR
 565         case FILE_EXR:
 566         case FILE_EXR_LIST:
 567                 file = new FileEXR(this->asset, this);
 568                 break;
 569 #endif
 570         case FILE_FLAC:
 571                 file = new FileFLAC(this->asset, this);
 572                 break;
 573
 574         case FILE_CR2:
 575         case FILE_CR2_LIST:
 576                 file = new FileCR2(this->asset, this);
 577                 break;
 578
 579         case FILE_TGA_LIST:
 580         case FILE_TGA:
 581                 file = new FileTGA(this->asset, this);
 582                 break;
 583
 584         case FILE_TIFF:
 585         case FILE_TIFF_LIST:
 586                 file = new FileTIFF(this->asset, this);
 587                 break;
 588
 589         case FILE_DB:
 590                 file = new FileDB(this->asset, this);
 591                 break;
 592
 593         case FILE_MPEG:
 594         case FILE_AMPEG:
 595         case FILE_VMPEG:
 596                 file = new FileMPEG(this->asset, this);
 597                 break;
 598
 599         case FILE_OGG:
 600                 file = new FileOGG(this->asset, this);
 601                 break;
 602
 603         case FILE_VORBIS:
 604                 file = new FileVorbis(this->asset, this);
 605                 break;
 606 #ifdef HAVE_DV
 607         case FILE_RAWDV:
 608                 file = new FileDV(this->asset, this);
 609                 break;
 610 #endif
 611 // try plugins
 612         default:
 613                 return 1;
 614                 break;
 615         }
 616
 617
 618 // Reopen file with correct parser and get header.
 619         if(file->open_file(rd, wr)) {
 620                 delete file;  file = 0;
 621                 return FILE_NOT_FOUND;
 622         }
 623
 624
 625
 626 // Set extra writing parameters to mandatory settings.
 627         if( wr ) {
 628                 if(this->asset->dither) file->set_dither();
 629         }
 630
 631         if( rd ) {
 632 // one frame image file, not brender, no specific length
 633                 if( !this->asset->audio_data && this->asset->use_header &&
 634                     this->asset->video_data && !this->asset->single_frame &&
 635                     this->asset->video_length >= 0 && this->asset->video_length <= 1 ) {
 636                         this->asset->single_frame = 1;
 637                         this->asset->video_length = -1;
 638                 }
 639         }
 640
 641 // Synchronize header parameters
 642         asset->copy_from(this->asset, 1);
 643 //asset->dump();
 644
 645         if(debug) printf("File::open_file %d file=%p\n", __LINE__, file);
 646 // sleep(1);
 647
 648         return FILE_OK;
 649 }
 650
 651 void File::delete_temp_samples_buffer()
 652 {
 653
 654         if(temp_samples_buffer) {
 655                 for(int j = 0; j < audio_ring_buffers; j++) {
 656                         for(int i = 0; i < asset->channels; i++) {
 657                                 delete temp_samples_buffer[j][i];
 658                         }
 659                         delete [] temp_samples_buffer[j];
 660                 }
 661
 662                 delete [] temp_samples_buffer;
 663                 temp_samples_buffer = 0;
 664                 audio_ring_buffers = 0;
 665         }
 666 }
 667
 668 void File::delete_temp_frame_buffer()
 669 {
 670
 671         if(temp_frame_buffer) {
 672                 for(int k = 0; k < video_ring_buffers; k++) {
 673                         for(int i = 0; i < asset->layers; i++) {
 674                                 for(int j = 0; j < video_buffer_size; j++) {
 675                                         delete temp_frame_buffer[k][i][j];
 676                                 }
 677                                 delete [] temp_frame_buffer[k][i];
 678                         }
 679                         delete [] temp_frame_buffer[k];
 680                 }
 681
 682                 delete [] temp_frame_buffer;
 683                 temp_frame_buffer = 0;
 684                 video_ring_buffers = 0;
 685                 video_buffer_size = 0;
 686         }
 687 }
 688
 689 int File::close_file(int ignore_thread)
 690 {
 691         const int debug = 0;
 692
 693         if(debug) printf("File::close_file file=%p %d\n", file, __LINE__);
 694
 695         if(!ignore_thread) {
 696                 stop_audio_thread();
 697                 stop_video_thread();
 698         }
 699
 700
 701         if(debug) printf("File::close_file file=%p %d\n", file, __LINE__);
 702         if(file) {
 703 // The file's asset is a copy of the argument passed to open_file so the
 704 // user must copy lengths from the file's asset.
 705                 if(asset && wr) {
 706                         asset->audio_length = current_sample;
 707                         asset->video_length = current_frame;
 708                 }
 709
 710                 file->close_file();
 711                 delete file;
 712         }
 713         if(debug) printf("File::close_file file=%p %d\n", file, __LINE__);
 714
 715         delete_temp_samples_buffer();
 716         delete_temp_frame_buffer();
 717         if(debug) printf("File::close_file file=%p %d\n", file, __LINE__);
 718
 719         if(debug) printf("File::close_file file=%p %d\n", file, __LINE__);
 720
 721         reset_parameters();
 722         if(debug) printf("File::close_file file=%p %d\n", file, __LINE__);
 723         return 0;
 724 }
 725
 726
 727
 728 int File::get_index(IndexFile *index_file, MainProgressBar *progress_bar)
 729 {
 730         return !file ? -1 : file->get_index(index_file, progress_bar);
 731 }
 732
 733
 734
 735 int File::start_audio_thread(int buffer_size, int ring_buffers)
 736 {
 737         this->audio_ring_buffers = ring_buffers;
 738
 739
 740         if(!audio_thread)
 741         {
 742                 audio_thread = new FileThread(this, 1, 0);
 743                 audio_thread->start_writing(buffer_size, 0, ring_buffers, 0);
 744         }
 745         return 0;
 746 }
 747
 748 int File::start_video_thread(int buffer_size,
 749         int color_model,
 750         int ring_buffers,
 751         int compressed)
 752 {
 753         this->video_ring_buffers = ring_buffers;
 754         this->video_buffer_size = buffer_size;
 755
 756         if(!video_thread)
 757         {
 758                 video_thread = new FileThread(this, 0, 1);
 759                 video_thread->start_writing(buffer_size,
 760                         color_model,
 761                         ring_buffers,
 762                         compressed);
 763         }
 764         return 0;
 765 }
 766
 767 int File::start_video_decode_thread()
 768 {
 769 // Currently, CR2 is the only one which won't work asynchronously, so
 770 // we're not using a virtual function yet.
 771         if(!video_thread /* && asset->format != FILE_CR2 */)
 772         {
 773                 video_thread = new FileThread(this, 0, 1);
 774                 video_thread->start_reading();
 775                 use_cache = 0;
 776         }
 777         return 0;
 778 }
 779
 780 int File::stop_audio_thread()
 781 {
 782         if(audio_thread)
 783         {
 784                 audio_thread->stop_writing();
 785                 delete audio_thread;
 786                 audio_thread = 0;
 787         }
 788         return 0;
 789 }
 790
 791 int File::stop_video_thread()
 792 {
 793         if(video_thread)
 794         {
 795                 video_thread->stop_reading();
 796                 video_thread->stop_writing();
 797                 delete video_thread;
 798                 video_thread = 0;
 799         }
 800         return 0;
 801 }
 802
 803 FileThread* File::get_video_thread()
 804 {
 805         return video_thread;
 806 }
 807
 808 int File::set_channel(int channel)
 809 {
 810         if(file && channel < asset->channels)
 811         {
 812                 current_channel = channel;
 813                 return 0;
 814         }
 815         else
 816                 return 1;
 817 }
 818
 819 int File::get_channel()
 820 {
 821         return current_channel;
 822 }
 823
 824 // if no>=0, sets new program
 825 //  returns current program
 826 int File::set_program(int no)
 827 {
 828         int result = file ? file->set_program(no) : current_program;
 829         current_program = no < 0 ? result : no;
 830         return result;
 831 }
 832
 833 int File::get_cell_time(int no, double &time)
 834 {
 835         return file ? file->get_cell_time(no, time) : -1;
 836 }
 837
 838 int File::get_system_time(int64_t &tm)
 839 {
 840         return file ? file->get_system_time(tm) : -1;
 841 }
 842
 843 int File::get_audio_for_video(int vstream, int astream, int64_t &channel_mask)
 844 {
 845         return file ? file->get_audio_for_video(vstream, astream, channel_mask) : -1;
 846 }
 847
 848 int File::get_video_pid(int track)
 849 {
 850         return file ? file->get_video_pid(track) : -1;
 851 }
 852
 853
 854
 855 int File::get_video_info(int track, int &pid, double &framerate,
 856                 int &width, int &height, char *title)
 857 {
 858         return !file ? -1 :
 859                  file->get_video_info(track, pid, framerate, width, height, title);
 860 }
 861
 862 int File::select_video_stream(Asset *asset, int vstream)
 863 {
 864         return !file ? -1 :
 865                  file->select_video_stream(asset, vstream);
 866 }
 867
 868 int File::select_audio_stream(Asset *asset, int astream)
 869 {
 870         return !file ? -1 :
 871                  file->select_audio_stream(asset, astream);
 872 }
 873
 874
 875 int File::get_thumbnail(int stream,
 876         int64_t &position, unsigned char *&thumbnail, int &ww, int &hh)
 877 {
 878         return file->get_thumbnail(stream, position, thumbnail, ww, hh);
 879 }
 880
 881 int File::set_skimming(int track, int skim, skim_fn fn, void *vp)
 882 {
 883         return file->set_skimming(track, skim, fn, vp);
 884 }
 885
 886 int File::skim_video(int track, void *vp, skim_fn fn)
 887 {
 888         return file->skim_video(track, vp, fn);
 889 }
 890
 891
 892 int File::set_layer(int layer, int is_thread)
 893 {
 894         if(file && layer < asset->layers)
 895         {
 896                 if(!is_thread && video_thread)
 897                 {
 898                         video_thread->set_layer(layer);
 899                 }
 900                 else
 901                 {
 902                         current_layer = layer;
 903                 }
 904                 return 0;
 905         }
 906         else
 907                 return 1;
 908 }
 909
 910 int64_t File::get_audio_length()
 911 {
 912         int64_t result = asset->audio_length;
 913         int64_t base_samplerate = -1;
 914         if(result > 0)
 915         {
 916                 if(base_samplerate > 0)
 917                         return (int64_t)((double)result / asset->sample_rate * base_samplerate + 0.5);
 918                 else
 919                         return result;
 920         }
 921         else
 922                 return -1;
 923 }
 924
 925 int64_t File::get_video_length()
 926 {
 927         int64_t result = asset->video_length;
 928         float base_framerate = -1;
 929         if(result > 0)
 930         {
 931                 if(base_framerate > 0)
 932                         return (int64_t)((double)result / asset->frame_rate * base_framerate + 0.5);
 933                 else
 934                         return result;
 935         }
 936         else
 937                 return -1;  // infinity
 938 }
 939
 940
 941 int64_t File::get_video_position()
 942 {
 943         float base_framerate = -1;
 944         if(base_framerate > 0)
 945                 return (int64_t)((double)current_frame / asset->frame_rate * base_framerate + 0.5);
 946         else
 947                 return current_frame;
 948 }
 949
 950 int64_t File::get_audio_position()
 951 {
 952 //      int64_t base_samplerate = -1;
 953 //      if(base_samplerate > 0)
 954 //      {
 955 //              if(normalized_sample_rate == base_samplerate)
 956 //                      return normalized_sample;
 957 //              else
 958 //                      return (int64_t)((double)current_sample /
 959 //                              asset->sample_rate *
 960 //                              base_samplerate +
 961 //                              0.5);
 962 //      }
 963 //      else
 964                 return current_sample;
 965 }
 966
 967
 968
 969 int File::set_audio_position(int64_t position)
 970 {
 971         int result = 0;
 972
 973         if(!file) return 1;
 974
 975 #define REPOSITION(x, y) \
 976         (labs((x) - (y)) > 1)
 977
 978         float base_samplerate = asset->sample_rate;
 979         current_sample = normalized_sample = position;
 980
 981 // printf("File::set_audio_position %d normalized_sample=%ld\n",
 982 // __LINE__,
 983 // normalized_sample);
 984                 result = file->set_audio_position(current_sample);
 985
 986                 if(result)
 987                         printf("File::set_audio_position position=%jd"
 988                                 " base_samplerate=%f asset=%p asset->sample_rate=%d\n",
 989                                 position, base_samplerate, asset, asset->sample_rate);
 990
 991 //printf("File::set_audio_position %d %d %d\n", current_channel, current_sample, position);
 992
 993         return result;
 994 }
 995
 996 int File::set_video_position(int64_t position,
 997         int is_thread)
 998 {
 999         int result = 0;
1000         if(!file) return 0;
1001
1002 // Convert to file's rate
1003 //      if(base_framerate > 0)
1004 //              position = (int64_t)((double)position /
1005 //                      base_framerate *
1006 //                      asset->frame_rate +
1007 //                      0.5);
1008
1009
1010         if(video_thread && !is_thread)
1011         {
1012 // Call thread.  Thread calls this again to set the file state.
1013                 video_thread->set_video_position(position);
1014         }
1015         else
1016         if(current_frame != position)
1017         {
1018                 if(file)
1019                 {
1020                         current_frame = position;
1021                         result = file->set_video_position(current_frame);
1022                 }
1023         }
1024
1025         return result;
1026 }
1027
1028 // No resampling here.
1029 int File::write_samples(Samples **buffer, int64_t len)
1030 {
1031         int result = 1;
1032
1033         if(file)
1034         {
1035                 write_lock->lock("File::write_samples");
1036
1037 // Convert to arrays for backwards compatability
1038                 double *temp[asset->channels];
1039                 for(int i = 0; i < asset->channels; i++)
1040                 {
1041                         temp[i] = buffer[i]->get_data();
1042                 }
1043
1044                 result = file->write_samples(temp, len);
1045                 current_sample += len;
1046                 normalized_sample += len;
1047                 asset->audio_length += len;
1048                 write_lock->unlock();
1049         }
1050         return result;
1051 }
1052
1053
1054
1055
1056
1057 // Can't put any cmodel abstraction here because the filebase couldn't be
1058 // parallel.
1059 int File::write_frames(VFrame ***frames, int len)
1060 {
1061 //printf("File::write_frames %d\n", __LINE__);
1062 //PRINT_TRACE
1063 // Store the counters in temps so the filebase can choose to overwrite them.
1064         int result;
1065         int current_frame_temp = current_frame;
1066         int video_length_temp = asset->video_length;
1067
1068         write_lock->lock("File::write_frames");
1069
1070 //PRINT_TRACE
1071         result = file->write_frames(frames, len);
1072 //PRINT_TRACE
1073
1074         current_frame = current_frame_temp + len;
1075         asset->video_length = video_length_temp + len;
1076         write_lock->unlock();
1077 //PRINT_TRACE
1078         return result;
1079 }
1080
1081 // Only called by FileThread
1082 int File::write_compressed_frame(VFrame *buffer)
1083 {
1084         int result = 0;
1085         write_lock->lock("File::write_compressed_frame");
1086         result = file->write_compressed_frame(buffer);
1087         current_frame++;
1088         asset->video_length++;
1089         write_lock->unlock();
1090         return result;
1091 }
1092
1093
1094 int File::write_audio_buffer(int64_t len)
1095 {
1096         int result = 0;
1097         if(audio_thread)
1098         {
1099                 result = audio_thread->write_buffer(len);
1100         }
1101         return result;
1102 }
1103
1104 int File::write_video_buffer(int64_t len)
1105 {
1106         int result = 0;
1107         if(video_thread)
1108         {
1109                 result = video_thread->write_buffer(len);
1110         }
1111
1112         return result;
1113 }
1114
1115 Samples** File::get_audio_buffer()
1116 {
1117         if(audio_thread) return audio_thread->get_audio_buffer();
1118         return 0;
1119 }
1120
1121 VFrame*** File::get_video_buffer()
1122 {
1123         if(video_thread)
1124         {
1125                 VFrame*** result = video_thread->get_video_buffer();
1126
1127                 return result;
1128         }
1129
1130         return 0;
1131 }
1132
1133
1134 int File::read_samples(Samples *samples, int64_t len)
1135 {
1136 // Never try to read more samples than exist in the file
1137         if (asset->audio_length >= 0 && current_sample + len > asset->audio_length) {
1138                 len = asset->audio_length - current_sample;
1139         }
1140         if(len <= 0) return 0;
1141
1142         int result = 0;
1143         const int debug = 0;
1144         if(debug) PRINT_TRACE
1145
1146         if(debug) PRINT_TRACE
1147
1148         double *buffer = samples->get_data();
1149
1150         int64_t base_samplerate = asset->sample_rate;
1151
1152         if(file)
1153         {
1154 // Resample recursively calls this with the asset sample rate
1155                 if(base_samplerate == 0) base_samplerate = asset->sample_rate;
1156
1157                 if(debug) PRINT_TRACE
1158                 result = file->read_samples(buffer, len);
1159
1160                 if(debug) PRINT_TRACE
1161                 current_sample += len;
1162
1163                 normalized_sample += len;
1164         }
1165         if(debug) PRINT_TRACE
1166
1167         return result;
1168 }
1169
1170 int File::read_frame(VFrame *frame, int is_thread)
1171 {
1172         const int debug = 0;
1173
1174         if(debug) PRINT_TRACE
1175
1176 //printf("File::read_frame %d\n", __LINE__);
1177
1178         if(video_thread && !is_thread) return video_thread->read_frame(frame);
1179
1180 //printf("File::read_frame %d\n", __LINE__);
1181         if(debug) PRINT_TRACE
1182         if( !file ) return 1;
1183         if(debug) PRINT_TRACE
1184         int result = 0;
1185         int supported_colormodel = colormodel_supported(frame->get_color_model());
1186         int advance_position = 1;
1187         int cache_active = use_cache || asset->single_frame ? 1 : 0;
1188         int64_t cache_position = !asset->single_frame ? current_frame : -1;
1189 // Test cache
1190         if( cache_active && frame_cache->get_frame(frame, cache_position,
1191                         current_layer, asset->frame_rate) )
1192         {
1193 // Can't advance position if cache used.
1194 //printf("File::read_frame %d\n", __LINE__);
1195                 advance_position = 0;
1196         }
1197 // Need temp
1198         else if(frame->get_color_model() != BC_COMPRESSED &&
1199                 (supported_colormodel != frame->get_color_model() ||
1200                 frame->get_w() != asset->width ||
1201                 frame->get_h() != asset->height))
1202         {
1203
1204 //                      printf("File::read_frame %d\n", __LINE__);
1205 // Can't advance position here because it needs to be added to cache
1206                 if(temp_frame)
1207                 {
1208                         if(!temp_frame->params_match(asset->width, asset->height, supported_colormodel))
1209                         {
1210                                 delete temp_frame;
1211                                 temp_frame = 0;
1212                         }
1213                 }
1214
1215 //                      printf("File::read_frame %d\n", __LINE__);
1216                 if(!temp_frame)
1217                 {
1218                         temp_frame = new VFrame(0,
1219                                 -1,
1220                                 asset->width,
1221                                 asset->height,
1222                                 supported_colormodel,
1223                                 -1);
1224                 }
1225
1226 //                      printf("File::read_frame %d\n", __LINE__);
1227                 temp_frame->copy_stacks(frame);
1228                 result = file->read_frame(temp_frame);
1229                 if( !result )
1230                         frame->transfer_from(temp_frame);
1231                 else if( result && frame->get_status() > 0 )
1232                         frame->set_status(-1);
1233 //printf("File::read_frame %d\n", __LINE__);
1234         }
1235         else
1236         {
1237 // Can't advance position here because it needs to be added to cache
1238 //printf("File::read_frame %d\n", __LINE__);
1239                 result = file->read_frame(frame);
1240                 if( result && frame->get_status() > 0 )
1241                         frame->set_status(-1);
1242 //for(int i = 0; i < 100 * 1000; i++) ((float*)frame->get_rows()[0])[i] = 1.0;
1243         }
1244
1245         if( result && !current_frame )
1246                 frame->clear_frame();
1247
1248         if( cache_active && advance_position && frame->get_status() > 0 )
1249                 frame_cache->put_frame(frame, cache_position,
1250                         current_layer, asset->frame_rate, 1, 0);
1251 //printf("File::read_frame %d\n", __LINE__);
1252
1253         if(advance_position) current_frame++;
1254         if(debug) PRINT_TRACE
1255         return 0;
1256 }
1257
1258 int File::can_copy_from(Asset *asset,
1259         int64_t position,
1260         int output_w,
1261         int output_h)
1262 {
1263         if( asset && file ) {
1264                 return asset->width == output_w &&
1265                         asset->height == output_h &&
1266                         file->can_copy_from(asset, position);
1267         }
1268         return 0;
1269 }
1270
1271 // Fill in queries about formats when adding formats here.
1272
1273
1274 int File::strtoformat(const char *format)
1275 {
1276         return strtoformat(0, format);
1277 }
1278
1279 int File::strtoformat(ArrayList<PluginServer*> *plugindb, const char *format)
1280 {
1281         if(!strcasecmp(format, _(AC3_NAME))) return FILE_AC3;
1282         if(!strcasecmp(format, _(SCENE_NAME))) return FILE_SCENE;
1283         if(!strcasecmp(format, _(WAV_NAME))) return FILE_WAV;
1284         if(!strcasecmp(format, _(PCM_NAME))) return FILE_PCM;
1285         if(!strcasecmp(format, _(AU_NAME))) return FILE_AU;
1286         if(!strcasecmp(format, _(AIFF_NAME))) return FILE_AIFF;
1287         if(!strcasecmp(format, _(SND_NAME))) return FILE_SND;
1288         if(!strcasecmp(format, _(PNG_NAME))) return FILE_PNG;
1289         if(!strcasecmp(format, _(PNG_LIST_NAME))) return FILE_PNG_LIST;
1290         if(!strcasecmp(format, _(TIFF_NAME))) return FILE_TIFF;
1291         if(!strcasecmp(format, _(TIFF_LIST_NAME))) return FILE_TIFF_LIST;
1292         if(!strcasecmp(format, _(JPEG_NAME))) return FILE_JPEG;
1293         if(!strcasecmp(format, _(JPEG_LIST_NAME))) return FILE_JPEG_LIST;
1294         if(!strcasecmp(format, _(EXR_NAME))) return FILE_EXR;
1295         if(!strcasecmp(format, _(EXR_LIST_NAME))) return FILE_EXR_LIST;
1296         if(!strcasecmp(format, _(FLAC_NAME))) return FILE_FLAC;
1297         if(!strcasecmp(format, _(CR2_NAME))) return FILE_CR2;
1298         if(!strcasecmp(format, _(CR2_LIST_NAME))) return FILE_CR2_LIST;
1299         if(!strcasecmp(format, _(MPEG_NAME))) return FILE_MPEG;
1300         if(!strcasecmp(format, _(AMPEG_NAME))) return FILE_AMPEG;
1301         if(!strcasecmp(format, _(VMPEG_NAME))) return FILE_VMPEG;
1302         if(!strcasecmp(format, _(TGA_NAME))) return FILE_TGA;
1303         if(!strcasecmp(format, _(TGA_LIST_NAME))) return FILE_TGA_LIST;
1304         if(!strcasecmp(format, _(OGG_NAME))) return FILE_OGG;
1305         if(!strcasecmp(format, _(VORBIS_NAME))) return FILE_VORBIS;
1306         if(!strcasecmp(format, _(RAWDV_NAME))) return FILE_RAWDV;
1307         if(!strcasecmp(format, _(FFMPEG_NAME))) return FILE_FFMPEG;
1308         if(!strcasecmp(format, _(DBASE_NAME))) return FILE_DB;
1309
1310         return 0;
1311 }
1312
1313
1314 const char* File::formattostr(int format)
1315 {
1316         return formattostr(0, format);
1317 }
1318
1319 const char* File::formattostr(ArrayList<PluginServer*> *plugindb, int format)
1320 {
1321         switch(format) {
1322         case FILE_SCENE:        return _(SCENE_NAME);
1323         case FILE_AC3:          return _(AC3_NAME);
1324         case FILE_WAV:          return _(WAV_NAME);
1325         case FILE_PCM:          return _(PCM_NAME);
1326         case FILE_AU:           return _(AU_NAME);
1327         case FILE_AIFF:         return _(AIFF_NAME);
1328         case FILE_SND:          return _(SND_NAME);
1329         case FILE_PNG:          return _(PNG_NAME);
1330         case FILE_PNG_LIST:     return _(PNG_LIST_NAME);
1331         case FILE_JPEG:         return _(JPEG_NAME);
1332         case FILE_JPEG_LIST:    return _(JPEG_LIST_NAME);
1333         case FILE_CR2:          return _(CR2_NAME);
1334         case FILE_CR2_LIST:     return _(CR2_LIST_NAME);
1335         case FILE_FLAC:         return _(FLAC_NAME);
1336         case FILE_EXR:          return _(EXR_NAME);
1337         case FILE_EXR_LIST:     return _(EXR_LIST_NAME);
1338         case FILE_MPEG:         return _(MPEG_NAME);
1339         case FILE_AMPEG:        return _(AMPEG_NAME);
1340         case FILE_VMPEG:        return _(VMPEG_NAME);
1341         case FILE_TGA:          return _(TGA_NAME);
1342         case FILE_TGA_LIST:     return _(TGA_LIST_NAME);
1343         case FILE_TIFF:         return _(TIFF_NAME);
1344         case FILE_TIFF_LIST:    return _(TIFF_LIST_NAME);
1345         case FILE_OGG:          return _(OGG_NAME);
1346         case FILE_VORBIS:       return _(VORBIS_NAME);
1347         case FILE_RAWDV:        return _(RAWDV_NAME);
1348         case FILE_FFMPEG:       return _(FFMPEG_NAME);
1349         case FILE_DB:           return _(DBASE_NAME);
1350         }
1351         return _("Unknown");
1352 }
1353
1354 int File::strtobits(const char *bits)
1355 {
1356         if(!strcasecmp(bits, _(NAME_8BIT))) return BITSLINEAR8;
1357         if(!strcasecmp(bits, _(NAME_16BIT))) return BITSLINEAR16;
1358         if(!strcasecmp(bits, _(NAME_24BIT))) return BITSLINEAR24;
1359         if(!strcasecmp(bits, _(NAME_32BIT))) return BITSLINEAR32;
1360         if(!strcasecmp(bits, _(NAME_ULAW))) return BITSULAW;
1361         if(!strcasecmp(bits, _(NAME_ADPCM))) return BITS_ADPCM;
1362         if(!strcasecmp(bits, _(NAME_FLOAT))) return BITSFLOAT;
1363         return BITSLINEAR16;
1364 }
1365
1366 const char* File::bitstostr(int bits)
1367 {
1368 //printf("File::bitstostr\n");
1369         switch(bits) {
1370         case BITSLINEAR8:       return (NAME_8BIT);
1371         case BITSLINEAR16:      return (NAME_16BIT);
1372         case BITSLINEAR24:      return (NAME_24BIT);
1373         case BITSLINEAR32:      return (NAME_32BIT);
1374         case BITSULAW:          return (NAME_ULAW);
1375         case BITS_ADPCM:        return (NAME_ADPCM);
1376         case BITSFLOAT:         return (NAME_FLOAT);
1377         }
1378         return _("Unknown");
1379 }
1380
1381
1382
1383 int File::str_to_byteorder(const char *string)
1384 {
1385         if(!strcasecmp(string, _("Lo Hi"))) return 1;
1386         return 0;
1387 }
1388
1389 const char* File::byteorder_to_str(int byte_order)
1390 {
1391         if(byte_order) return _("Lo Hi");
1392         return _("Hi Lo");
1393 }
1394
1395 int File::bytes_per_sample(int bits)
1396 {
1397         switch(bits)
1398         {
1399                 case BITSLINEAR8:       return 1;
1400                 case BITSLINEAR16:      return 2;
1401                 case BITSLINEAR24:      return 3;
1402                 case BITSLINEAR32:      return 4;
1403                 case BITSULAW:          return 1;
1404         }
1405         return 1;
1406 }
1407
1408
1409
1410
1411
1412 int File::get_best_colormodel(int driver)
1413 {
1414         return get_best_colormodel(asset, driver);
1415 }
1416
1417 int File::get_best_colormodel(Asset *asset, int driver)
1418 {
1419         switch(asset->format)
1420         {
1421 #ifdef HAVE_DV
1422                 case FILE_RAWDV:        return FileDV::get_best_colormodel(asset, driver);
1423 #endif
1424                 case FILE_MPEG:         return FileMPEG::get_best_colormodel(asset, driver);
1425                 case FILE_JPEG:
1426                 case FILE_JPEG_LIST:    return FileJPEG::get_best_colormodel(asset, driver);
1427 #ifdef HAVE_OPENEXR
1428                 case FILE_EXR:
1429                 case FILE_EXR_LIST:     return FileEXR::get_best_colormodel(asset, driver);
1430 #endif
1431                 case FILE_PNG:
1432                 case FILE_PNG_LIST:     return FilePNG::get_best_colormodel(asset, driver);
1433                 case FILE_TGA:
1434                 case FILE_TGA_LIST:     return FileTGA::get_best_colormodel(asset, driver);
1435                 case FILE_CR2:
1436                 case FILE_CR2_LIST:     return FileCR2::get_best_colormodel(asset, driver);
1437                 case FILE_DB:           return FileDB::get_best_colormodel(asset, driver);
1438                 case FILE_FFMPEG:       return FileFFMPEG::get_best_colormodel(asset, driver);
1439         }
1440
1441         return BC_RGB888;
1442 }
1443
1444
1445 int File::colormodel_supported(int colormodel)
1446 {
1447         if(file)
1448                 return file->colormodel_supported(colormodel);
1449
1450         return BC_RGB888;
1451 }
1452
1453
1454 int64_t File::file_memory_usage()
1455 {
1456         return file ? file->base_memory_usage() : 0;
1457 }
1458
1459 int64_t File::get_memory_usage()
1460 {
1461         int64_t result = 0;
1462
1463         result += file_memory_usage();
1464         if(temp_frame) result += temp_frame->get_data_size();
1465         result += frame_cache->get_memory_usage();
1466         if(video_thread) result += video_thread->get_memory_usage();
1467
1468         if(result < MIN_CACHEITEM_SIZE) result = MIN_CACHEITEM_SIZE;
1469         return result;
1470 }
1471
1472
1473 int File::supports_video(ArrayList<PluginServer*> *plugindb, char *format)
1474 {
1475         int format_i = strtoformat(plugindb, format);
1476
1477         return supports_video(format_i);
1478         return 0;
1479 }
1480
1481 int File::supports_audio(ArrayList<PluginServer*> *plugindb, char *format)
1482 {
1483         int format_i = strtoformat(plugindb, format);
1484
1485         return supports_audio(format_i);
1486         return 0;
1487 }
1488
1489
1490 int File::supports_video(int format)
1491 {
1492 //printf("File::supports_video %d\n", format);
1493         switch(format)
1494         {
1495                 case FILE_OGG:
1496                 case FILE_JPEG:
1497                 case FILE_JPEG_LIST:
1498                 case FILE_CR2:
1499                 case FILE_CR2_LIST:
1500                 case FILE_EXR:
1501                 case FILE_EXR_LIST:
1502                 case FILE_PNG:
1503                 case FILE_PNG_LIST:
1504                 case FILE_TGA:
1505                 case FILE_TGA_LIST:
1506                 case FILE_TIFF:
1507                 case FILE_TIFF_LIST:
1508                 case FILE_VMPEG:
1509                 case FILE_FFMPEG:
1510                 case FILE_RAWDV:
1511                         return 1;
1512         }
1513         return 0;
1514 }
1515
1516 int File::supports_audio(int format)
1517 {
1518         switch(format)
1519         {
1520                 case FILE_AC3:
1521                 case FILE_FLAC:
1522                 case FILE_PCM:
1523                 case FILE_WAV:
1524                 case FILE_OGG:
1525                 case FILE_VORBIS:
1526                 case FILE_AMPEG:
1527                 case FILE_AU:
1528                 case FILE_AIFF:
1529                 case FILE_SND:
1530                 case FILE_FFMPEG:
1531                 case FILE_RAWDV:
1532                         return 1;
1533         }
1534         return 0;
1535 }
1536
1537 const char* File::get_tag(int format)
1538 {
1539         switch(format)
1540         {
1541                 case FILE_AC3:          return "ac3";
1542                 case FILE_AIFF:         return "aif";
1543                 case FILE_AMPEG:        return "mp3";
1544                 case FILE_AU:           return "au";
1545                 case FILE_RAWDV:        return "dv";
1546                 case FILE_DB:           return "db";
1547                 case FILE_EXR:          return "exr";
1548                 case FILE_EXR_LIST:     return "exr";
1549                 case FILE_FLAC:         return "flac";
1550                 case FILE_JPEG:         return "jpg";
1551                 case FILE_JPEG_LIST:    return "jpg";
1552                 case FILE_OGG:          return "ogg";
1553                 case FILE_PCM:          return "pcm";
1554                 case FILE_PNG:          return "png";
1555                 case FILE_PNG_LIST:     return "png";
1556                 case FILE_TGA:          return "tga";
1557                 case FILE_TGA_LIST:     return "tga";
1558                 case FILE_TIFF:         return "tif";
1559                 case FILE_TIFF_LIST:    return "tif";
1560                 case FILE_VMPEG:        return "m2v";
1561                 case FILE_VORBIS:       return "ogg";
1562                 case FILE_WAV:          return "wav";
1563                 case FILE_FFMPEG:       return "ffmpg";
1564         }
1565         return 0;
1566 }
1567
1568 const char* File::get_prefix(int format)
1569 {
1570         switch(format) {
1571         case FILE_PCM:          return "PCM";
1572         case FILE_WAV:          return "WAV";
1573         case FILE_PNG:          return "PNG";
1574         case FILE_JPEG:         return "JPEG";
1575         case FILE_TIFF:         return "TIFF";
1576         case FILE_GIF:          return "GIF";
1577         case FILE_JPEG_LIST:    return "JPEG_LIST";
1578         case FILE_AU:           return "AU";
1579         case FILE_AIFF:         return "AIFF";
1580         case FILE_SND:          return "SND";
1581         case FILE_TGA_LIST:     return "TGA_LIST";
1582         case FILE_TGA:          return "TGA";
1583         case FILE_MPEG:         return "MPEG";
1584         case FILE_AMPEG:        return "AMPEG";
1585         case FILE_VMPEG:        return "VMPEG";
1586         case FILE_RAWDV:        return "RAWDV";
1587         case FILE_TIFF_LIST:    return "TIFF_LIST";
1588         case FILE_PNG_LIST:     return "PNG_LIST";
1589         case FILE_AC3:          return "AC3";
1590         case FILE_EXR:          return "EXR";
1591         case FILE_EXR_LIST:     return "EXR_LIST";
1592         case FILE_CR2:          return "CR2";
1593         case FILE_OGG:          return "OGG";
1594         case FILE_VORBIS:       return "VORBIS";
1595         case FILE_FLAC:         return "FLAC";
1596         case FILE_FFMPEG:       return "FFMPEG";
1597         case FILE_SCENE:        return "SCENE";
1598         case FILE_CR2_LIST:     return "CR2_LIST";
1599         case FILE_GIF_LIST:     return "GIF_LIST";
1600         case FILE_DB:           return "DB";
1601         }
1602         return _("UNKNOWN");
1603 }
1604
1605
1606 PackagingEngine *File::new_packaging_engine(Asset *asset)
1607 {
1608         PackagingEngine *result;
1609         switch (asset->format)
1610         {
1611                 case FILE_OGG:
1612                         result = (PackagingEngine*)new PackagingEngineOGG();
1613                         break;
1614                 default:
1615                         result = (PackagingEngine*) new PackagingEngineDefault();
1616                         break;
1617         }
1618
1619         return result;
1620 }
1621
1622
1623 int File::record_fd()
1624 {
1625         return file ? file->record_fd() : -1;
1626 }
1627
1628
1629 void File::get_exe_path(char *result, char *bnp)
1630 {
1631 // Get executable path, basename
1632         int len = readlink("/proc/self/exe", result, BCTEXTLEN-1);
1633         if( len >= 0 ) {
1634                 result[len] = 0;
1635                 char *ptr = strrchr(result, '/');
1636                 if( ptr ) *ptr++ = 0; else ptr = result;
1637                 if( bnp ) strncpy(bnp, ptr, BCTEXTLEN);
1638         }
1639         else {
1640                 *result = 0;
1641                 if( bnp ) *bnp = 0;
1642         }
1643 }
1644
1645 void File::getenv_path(char *result, const char *path)
1646 {
1647         char *rp = result, *ep = rp + BCTEXTLEN-1;
1648         const char *cp = path;
1649 // any env var can be used here to expand a path as:
1650 //   "path...$id...": and id is a word as alpha,alnum...
1651 //   expands as "path...getenv(id)..."
1652 // CIN_PATH, CIN_LIB are set in main.C,
1653         for( int ch=*cp++; ch && rp < ep; ch=*cp++ ) {
1654                 if( ch == '$' && isalpha(*cp) ) { // scan alpha,alnum...
1655                         const char *bp = cp;  char *p = rp;
1656                         while( p < ep && *bp && (isalnum(*bp) || *bp == '_') ) *p++ = *bp++;
1657                         *p = 0;
1658                         const char *envp = getenv(rp); // read env value
1659                         if( !envp ) continue;
1660                         while( *envp && rp < ep ) *rp++ = *envp++;
1661                         cp = bp;                 // subst id=value
1662                         continue;
1663                 }
1664                 *rp++ = ch;
1665         }
1666         *rp = 0;
1667 }
1668
1669 void File::setenv_path(char *result, const char *var, const char *path)
1670 {
1671         char *env = getenv(var);
1672         if( env ) return;
1673         char env_path[BCTEXTLEN];
1674         getenv_path(env_path, path);
1675         sprintf(result, "%s=%s", var, env_path);
1676         putenv(result);
1677 }
1678
1679 char File::cinexe_path[BCTEXTLEN];
1680 char File::cinpkg_path[BCTEXTLEN];
1681 char File::cindat_path[BCTEXTLEN];
1682 char File::cinlib_path[BCTEXTLEN];
1683 char File::cincfg_path[BCTEXTLEN];
1684 char File::cinplg_path[BCTEXTLEN];
1685 char File::cinlad_path[BCTEXTLEN];
1686 char File::cinlcl_path[BCTEXTLEN];
1687 char File::cinbwr_path[BCTEXTLEN];
1688
1689 void File::init_cin_path()
1690 {
1691         char env_path[BCTEXTLEN], env_pkg[BCTEXTLEN];
1692 // these values are advertised for forks/shell scripts
1693         get_exe_path(env_path, env_pkg);
1694         snprintf(cinexe_path, sizeof(cinexe_path), "CIN_PATH=%s", env_path);
1695         putenv(cinexe_path);
1696         snprintf(cinpkg_path, sizeof(cinpkg_path), "CIN_PKG=%s", env_pkg);
1697         putenv(cinpkg_path);
1698
1699         setenv_path(cindat_path, "CIN_DAT", CINDAT_DIR);
1700         setenv_path(cinlib_path, "CIN_LIB", CINLIB_DIR);
1701         setenv_path(cincfg_path, "CIN_CONFIG", CONFIG_DIR);
1702         setenv_path(cinplg_path, "CIN_PLUGIN", PLUGIN_DIR);
1703         setenv_path(cinlad_path, "CIN_LADSPA", LADSPA_DIR);
1704         setenv_path(cinlcl_path, "CIN_LOCALE", LOCALE_DIR);
1705         setenv_path(cinbwr_path, "CIN_BROWSER", CIN_BROWSER);
1706 }
1707
1708