3 * Copyright (C) 2010 Adam Williams <broadcast at earthling dot net>
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.
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.
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
29 // work arounds (centos)
32 #define INT64_MAX 9223372036854775807LL
37 #include "bcsignals.h"
38 #include "byteorder.h"
40 #include "condition.h"
48 #include "fileffmpeg.h"
54 #undef HAVE_STDLIB_H // automake conflict
57 #include "filescene.h"
58 #include "filesndfile.h"
60 #include "filethread.h"
62 #include "filevorbis.h"
64 #include "formatwindow.h"
65 #include "formattools.h"
66 #include "framecache.h"
68 #include "mainprogress.inc"
71 #include "packagingengine.h"
72 #include "pluginserver.h"
73 #include "preferences.h"
74 #include "probeprefs.h"
78 //suppress noref warning
79 void *vorbis0_ov_callbacks[] = {
80 &OV_CALLBACKS_DEFAULT, &OV_CALLBACKS_NOCLOSE,
81 &OV_CALLBACKS_STREAMONLY, &OV_CALLBACKS_STREAMONLY_NOCLOSE,
88 format_completion = new Condition(1, "File::format_completion");
89 write_lock = new Condition(1, "File::write_lock");
90 frame_cache = new FrameCache;
98 if(format_window) format_window->set_done(0);
99 format_completion->lock("File::~File");
100 format_completion->unlock();
103 if(temp_frame) delete temp_frame;
108 asset->Garbage::remove_user();
109 delete format_completion;
114 void File::reset_parameters()
127 normalized_sample = 0;
130 playback_subtitle = -1;
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;
142 int File::raise_window()
144 if(getting_options && format_window)
146 format_window->raise_window();
147 format_window->flush();
152 void File::close_window()
156 format_window->lock_window("File::close_window");
157 format_window->set_done(1);
158 format_window->unlock_window();
163 int File::get_options(FormatTools *format,
164 int audio_options, int video_options)
166 BC_WindowBase *parent_window = format->window;
167 //ArrayList<PluginServer*> *plugindb = format->plugindb;
168 Asset *asset = format->asset;
171 format_completion->lock("File::get_options");
172 switch(asset->format)
175 FileAC3::get_parameters(parent_window,
183 FileDV::get_parameters(parent_window,
195 FileSndFile::get_parameters(parent_window,
202 FileFFMPEG::get_parameters(parent_window,
210 FileMPEG::get_parameters(parent_window,
218 FileJPEG::get_parameters(parent_window,
226 FileEXR::get_parameters(parent_window,
233 FileFLAC::get_parameters(parent_window,
241 FilePNG::get_parameters(parent_window,
249 FileTGA::get_parameters(parent_window,
257 FileTIFF::get_parameters(parent_window,
264 FileOGG::get_parameters(parent_window,
276 ErrorBox *errorbox = new ErrorBox(_(PROGRAM_NAME ": Error"),
277 parent_window->get_abs_cursor_x(1),
278 parent_window->get_abs_cursor_y(1));
279 format_window = errorbox;
282 errorbox->create_objects(_("This format doesn't support audio."));
285 errorbox->create_objects(_("This format doesn't support video."));
286 errorbox->run_window();
292 format_completion->unlock();
305 int File::set_processors(int cpus) // Set the number of cpus for certain codecs
307 if( cpus > 8 ) // mpegvideo max_threads = 16, more causes errs
308 cpus = 8; // 8 cpus ought to decode just about anything
309 // Set all instances so gets work.
315 int File::set_preload(int64_t size)
317 this->playback_preload = size;
321 void File::set_subtitle(int value)
323 this->playback_subtitle = value;
324 if( file ) file->set_subtitle(value);
327 void File::set_interpolate_raw(int value)
329 this->interpolate_raw = value;
332 void File::set_white_balance_raw(int value)
334 this->white_balance_raw = value;
338 void File::set_cache_frames(int value)
340 // caching only done locally
345 int File::purge_cache()
347 // caching only done locally
349 if( frame_cache->cache_items() > 0 )
351 frame_cache->remove_all();
357 int File::delete_oldest()
359 // caching only done locally
360 return frame_cache->delete_oldest();
363 // file driver in order of probe precidence
364 // can be reordered in preferences->interface
365 const char *File::default_probes[] = {
387 const int File::nb_probes =
388 sizeof(File::default_probes)/sizeof(File::default_probes[0]);
393 FILE *fp = fopen(this->asset->path, "rb");
394 if( !fp ) return FILE_NOT_FOUND;
396 memset(data,0,sizeof(data));
397 int ret = fread(data, 1, 16, fp);
399 if( !ret ) return FILE_NOT_FOUND;
401 for( int i=0; i<preferences->file_probes.size(); ++i ) {
402 ProbePref *pref = preferences->file_probes[i];
403 if( !pref->armed ) continue;
404 if( !strncmp(pref->name,"FFMPEG",6) ) { // FFMPEG Early/Late
405 if( !FileFFMPEG::check_sig(this->asset) ) continue;
406 file = new FileFFMPEG(this->asset, this);
409 if( !strcmp(pref->name,"DB") ) { // MediaDB
410 if( !FileDB::check_sig(this->asset) ) continue;
411 file = new FileDB(this->asset, this);
414 if( !strcmp(pref->name,"Scene") ) { // scene file
415 if( !FileScene::check_sig(this->asset, data)) continue;
416 file = new FileScene(this->asset, this);
420 if( !strcmp(pref->name,"DV") ) { // libdv
421 if( !FileDV::check_sig(this->asset) ) continue;
422 file = new FileDV(this->asset, this);
426 if( !strcmp(pref->name,"SndFile") ) { // libsndfile
427 if( !FileSndFile::check_sig(this->asset) ) continue;
428 file = new FileSndFile(this->asset, this);
431 if( !strcmp(pref->name,"PNG") ) { // PNG file
432 if( !FilePNG::check_sig(this->asset) ) continue;
433 file = new FilePNG(this->asset, this);
436 if( !strcmp(pref->name,"JPEG") ) { // JPEG file
437 if( !FileJPEG::check_sig(this->asset) ) continue;
438 file = new FileJPEG(this->asset, this);
441 if( !strcmp(pref->name,"GIF") ) { // GIF file
442 if( !FileGIF::check_sig(this->asset)) continue;
443 file = new FileGIF(this->asset, this);
446 if( !strcmp(pref->name,"EXR") ) { // EXR file
447 if( !FileEXR::check_sig(this->asset, data)) continue;
448 file = new FileEXR(this->asset, this);
451 if( !strcmp(pref->name,"FLAC") ) { // FLAC file
452 if( !FileFLAC::check_sig(this->asset, data)) continue;
453 file = new FileFLAC(this->asset, this);
456 if( !strcmp(pref->name,"CR2") ) { // CR2 file
457 if( !FileCR2::check_sig(this->asset)) continue;
458 file = new FileCR2(this->asset, this);
461 if( !strcmp(pref->name,"TGA") ) { // TGA file
462 if( !FileTGA::check_sig(this->asset) ) continue;
463 file = new FileTGA(this->asset, this);
466 if( !strcmp(pref->name,"TIFF") ) { // TIFF file
467 if( !FileTIFF::check_sig(this->asset) ) continue;
468 file = new FileTIFF(this->asset, this);
471 if( !strcmp(pref->name,"OGG") ) { // OGG file
472 if( !FileOGG::check_sig(this->asset) ) continue;
473 file = new FileOGG(this->asset, this);
476 if( !strcmp(pref->name,"Vorbis") ) { // VorbisFile file
477 if( !FileVorbis::check_sig(this->asset) ) continue;
478 file = new FileVorbis(this->asset, this);
481 if( !strcmp(pref->name,"MPEG") ) { // MPEG file
482 if( !FileMPEG::check_sig(this->asset) ) continue;
483 file = new FileMPEG(this->asset, this);
486 if( !strcmp(pref->name,"EDL") ) { // XML file
487 if( data[0] != '<' ) continue;
488 if( !strncmp(&data[1],"EDL>",4) ||
489 !strncmp(&data[1],"HTAL>",5) ||
490 !strncmp(&data[1],"?xml",4) )
494 return FILE_UNRECOGNIZED_CODEC; // maybe PCM file ?
497 int File::open_file(Preferences *preferences,
504 this->preferences = preferences;
505 this->asset->copy_from(asset, 1);
510 if(debug) printf("File::open_file %d\n", __LINE__);
512 if(debug) printf("File::open_file %p %d\n", this, __LINE__);
514 switch(this->asset->format) {
515 // get the format now
516 // If you add another format to case 0, you also need to add another case for the
517 // file format #define.
520 if( ret != FILE_OK ) return ret;
522 // format already determined
524 file = new FileAC3(this->asset, this);
528 file = new FileScene(this->asset, this);
532 file = new FileFFMPEG(this->asset, this);
540 //printf("File::open_file 1\n");
541 file = new FileSndFile(this->asset, this);
546 file = new FilePNG(this->asset, this);
551 file = new FileJPEG(this->asset, this);
556 file = new FileGIF(this->asset, this);
561 file = new FileEXR(this->asset, this);
565 file = new FileFLAC(this->asset, this);
570 file = new FileCR2(this->asset, this);
575 file = new FileTGA(this->asset, this);
580 file = new FileTIFF(this->asset, this);
584 file = new FileDB(this->asset, this);
590 file = new FileMPEG(this->asset, this);
594 file = new FileOGG(this->asset, this);
598 file = new FileVorbis(this->asset, this);
602 file = new FileDV(this->asset, this);
612 // Reopen file with correct parser and get header.
613 if(file->open_file(rd, wr)) {
614 delete file; file = 0;
615 return FILE_NOT_FOUND;
620 // Set extra writing parameters to mandatory settings.
622 if(this->asset->dither) file->set_dither();
626 // one frame image file, not brender, no specific length
627 if( !this->asset->audio_data && this->asset->use_header &&
628 this->asset->video_data && !this->asset->single_frame &&
629 this->asset->video_length >= 0 && this->asset->video_length <= 1 ) {
630 this->asset->single_frame = 1;
631 this->asset->video_length = -1;
635 // Synchronize header parameters
636 asset->copy_from(this->asset, 1);
639 if(debug) printf("File::open_file %d file=%p\n", __LINE__, file);
645 void File::delete_temp_samples_buffer()
648 if(temp_samples_buffer) {
649 for(int j = 0; j < audio_ring_buffers; j++) {
650 for(int i = 0; i < asset->channels; i++) {
651 delete temp_samples_buffer[j][i];
653 delete [] temp_samples_buffer[j];
656 delete [] temp_samples_buffer;
657 temp_samples_buffer = 0;
658 audio_ring_buffers = 0;
662 void File::delete_temp_frame_buffer()
665 if(temp_frame_buffer) {
666 for(int k = 0; k < video_ring_buffers; k++) {
667 for(int i = 0; i < asset->layers; i++) {
668 for(int j = 0; j < video_buffer_size; j++) {
669 delete temp_frame_buffer[k][i][j];
671 delete [] temp_frame_buffer[k][i];
673 delete [] temp_frame_buffer[k];
676 delete [] temp_frame_buffer;
677 temp_frame_buffer = 0;
678 video_ring_buffers = 0;
679 video_buffer_size = 0;
683 int File::close_file(int ignore_thread)
687 if(debug) printf("File::close_file file=%p %d\n", file, __LINE__);
695 if(debug) printf("File::close_file file=%p %d\n", file, __LINE__);
697 // The file's asset is a copy of the argument passed to open_file so the
698 // user must copy lengths from the file's asset.
700 asset->audio_length = current_sample;
701 asset->video_length = current_frame;
707 if(debug) printf("File::close_file file=%p %d\n", file, __LINE__);
709 delete_temp_samples_buffer();
710 delete_temp_frame_buffer();
711 if(debug) printf("File::close_file file=%p %d\n", file, __LINE__);
713 if(debug) printf("File::close_file file=%p %d\n", file, __LINE__);
716 if(debug) printf("File::close_file file=%p %d\n", file, __LINE__);
722 int File::get_index(IndexFile *index_file, MainProgressBar *progress_bar)
724 return !file ? -1 : file->get_index(index_file, progress_bar);
729 int File::start_audio_thread(int buffer_size, int ring_buffers)
731 this->audio_ring_buffers = ring_buffers;
736 audio_thread = new FileThread(this, 1, 0);
737 audio_thread->start_writing(buffer_size, 0, ring_buffers, 0);
742 int File::start_video_thread(int buffer_size,
747 this->video_ring_buffers = ring_buffers;
748 this->video_buffer_size = buffer_size;
752 video_thread = new FileThread(this, 0, 1);
753 video_thread->start_writing(buffer_size,
761 int File::start_video_decode_thread()
763 // Currently, CR2 is the only one which won't work asynchronously, so
764 // we're not using a virtual function yet.
765 if(!video_thread /* && asset->format != FILE_CR2 */)
767 video_thread = new FileThread(this, 0, 1);
768 video_thread->start_reading();
774 int File::stop_audio_thread()
778 audio_thread->stop_writing();
785 int File::stop_video_thread()
789 video_thread->stop_reading();
790 video_thread->stop_writing();
797 FileThread* File::get_video_thread()
802 int File::set_channel(int channel)
804 if(file && channel < asset->channels)
806 current_channel = channel;
813 int File::get_channel()
815 return current_channel;
818 // if no>=0, sets new program
819 // returns current program
820 int File::set_program(int no)
822 int result = file ? file->set_program(no) : current_program;
823 current_program = no < 0 ? result : no;
827 int File::get_cell_time(int no, double &time)
829 return file ? file->get_cell_time(no, time) : -1;
832 int File::get_system_time(int64_t &tm)
834 return file ? file->get_system_time(tm) : -1;
837 int File::get_audio_for_video(int vstream, int astream, int64_t &channel_mask)
839 return file ? file->get_audio_for_video(vstream, astream, channel_mask) : -1;
842 int File::get_video_pid(int track)
844 return file ? file->get_video_pid(track) : -1;
849 int File::get_video_info(int track, int &pid, double &framerate,
850 int &width, int &height, char *title)
853 file->get_video_info(track, pid, framerate, width, height, title);
856 int File::select_video_stream(Asset *asset, int vstream)
859 file->select_video_stream(asset, vstream);
862 int File::select_audio_stream(Asset *asset, int astream)
865 file->select_audio_stream(asset, astream);
869 int File::get_thumbnail(int stream,
870 int64_t &position, unsigned char *&thumbnail, int &ww, int &hh)
872 return file->get_thumbnail(stream, position, thumbnail, ww, hh);
875 int File::set_skimming(int track, int skim, skim_fn fn, void *vp)
877 return file->set_skimming(track, skim, fn, vp);
880 int File::skim_video(int track, void *vp, skim_fn fn)
882 return file->skim_video(track, vp, fn);
886 int File::set_layer(int layer, int is_thread)
888 if(file && layer < asset->layers)
890 if(!is_thread && video_thread)
892 video_thread->set_layer(layer);
896 current_layer = layer;
904 int64_t File::get_audio_length()
906 int64_t result = asset->audio_length;
907 int64_t base_samplerate = -1;
910 if(base_samplerate > 0)
911 return (int64_t)((double)result / asset->sample_rate * base_samplerate + 0.5);
919 int64_t File::get_video_length()
921 int64_t result = asset->video_length;
922 float base_framerate = -1;
925 if(base_framerate > 0)
926 return (int64_t)((double)result / asset->frame_rate * base_framerate + 0.5);
931 return -1; // infinity
935 int64_t File::get_video_position()
937 float base_framerate = -1;
938 if(base_framerate > 0)
939 return (int64_t)((double)current_frame / asset->frame_rate * base_framerate + 0.5);
941 return current_frame;
944 int64_t File::get_audio_position()
946 // int64_t base_samplerate = -1;
947 // if(base_samplerate > 0)
949 // if(normalized_sample_rate == base_samplerate)
950 // return normalized_sample;
952 // return (int64_t)((double)current_sample /
953 // asset->sample_rate *
958 return current_sample;
963 int File::set_audio_position(int64_t position)
969 #define REPOSITION(x, y) \
970 (labs((x) - (y)) > 1)
972 float base_samplerate = asset->sample_rate;
973 current_sample = normalized_sample = position;
975 // printf("File::set_audio_position %d normalized_sample=%ld\n",
977 // normalized_sample);
978 result = file->set_audio_position(current_sample);
981 printf("File::set_audio_position position=%jd"
982 " base_samplerate=%f asset=%p asset->sample_rate=%d\n",
983 position, base_samplerate, asset, asset->sample_rate);
985 //printf("File::set_audio_position %d %d %d\n", current_channel, current_sample, position);
990 int File::set_video_position(int64_t position,
996 // Convert to file's rate
997 // if(base_framerate > 0)
998 // position = (int64_t)((double)position /
1000 // asset->frame_rate +
1004 if(video_thread && !is_thread)
1006 // Call thread. Thread calls this again to set the file state.
1007 video_thread->set_video_position(position);
1010 if(current_frame != position)
1014 current_frame = position;
1015 result = file->set_video_position(current_frame);
1022 // No resampling here.
1023 int File::write_samples(Samples **buffer, int64_t len)
1029 write_lock->lock("File::write_samples");
1031 // Convert to arrays for backwards compatability
1032 double *temp[asset->channels];
1033 for(int i = 0; i < asset->channels; i++)
1035 temp[i] = buffer[i]->get_data();
1038 result = file->write_samples(temp, len);
1039 current_sample += len;
1040 normalized_sample += len;
1041 asset->audio_length += len;
1042 write_lock->unlock();
1051 // Can't put any cmodel abstraction here because the filebase couldn't be
1053 int File::write_frames(VFrame ***frames, int len)
1055 //printf("File::write_frames %d\n", __LINE__);
1057 // Store the counters in temps so the filebase can choose to overwrite them.
1059 int current_frame_temp = current_frame;
1060 int video_length_temp = asset->video_length;
1062 write_lock->lock("File::write_frames");
1065 result = file->write_frames(frames, len);
1068 current_frame = current_frame_temp + len;
1069 asset->video_length = video_length_temp + len;
1070 write_lock->unlock();
1075 // Only called by FileThread
1076 int File::write_compressed_frame(VFrame *buffer)
1079 write_lock->lock("File::write_compressed_frame");
1080 result = file->write_compressed_frame(buffer);
1082 asset->video_length++;
1083 write_lock->unlock();
1088 int File::write_audio_buffer(int64_t len)
1093 result = audio_thread->write_buffer(len);
1098 int File::write_video_buffer(int64_t len)
1103 result = video_thread->write_buffer(len);
1109 Samples** File::get_audio_buffer()
1111 if(audio_thread) return audio_thread->get_audio_buffer();
1115 VFrame*** File::get_video_buffer()
1119 VFrame*** result = video_thread->get_video_buffer();
1128 int File::read_samples(Samples *samples, int64_t len)
1130 // Never try to read more samples than exist in the file
1131 if (asset->audio_length >= 0 && current_sample + len > asset->audio_length) {
1132 len = asset->audio_length - current_sample;
1134 if(len <= 0) return 0;
1137 const int debug = 0;
1138 if(debug) PRINT_TRACE
1140 if(debug) PRINT_TRACE
1142 double *buffer = samples->get_data();
1144 int64_t base_samplerate = asset->sample_rate;
1148 // Resample recursively calls this with the asset sample rate
1149 if(base_samplerate == 0) base_samplerate = asset->sample_rate;
1151 if(debug) PRINT_TRACE
1152 result = file->read_samples(buffer, len);
1154 if(debug) PRINT_TRACE
1155 current_sample += len;
1157 normalized_sample += len;
1159 if(debug) PRINT_TRACE
1164 int File::read_frame(VFrame *frame, int is_thread)
1166 const int debug = 0;
1168 if(debug) PRINT_TRACE
1170 //printf("File::read_frame %d\n", __LINE__);
1172 if(video_thread && !is_thread) return video_thread->read_frame(frame);
1174 //printf("File::read_frame %d\n", __LINE__);
1175 if(debug) PRINT_TRACE
1176 if( !file ) return 1;
1177 if(debug) PRINT_TRACE
1179 int supported_colormodel = colormodel_supported(frame->get_color_model());
1180 int advance_position = 1;
1181 int cache_active = use_cache || asset->single_frame ? 1 : 0;
1182 int64_t cache_position = !asset->single_frame ? current_frame : -1;
1184 if( cache_active && frame_cache->get_frame(frame, cache_position,
1185 current_layer, asset->frame_rate) )
1187 // Can't advance position if cache used.
1188 //printf("File::read_frame %d\n", __LINE__);
1189 advance_position = 0;
1192 else if(frame->get_color_model() != BC_COMPRESSED &&
1193 (supported_colormodel != frame->get_color_model() ||
1194 frame->get_w() != asset->width ||
1195 frame->get_h() != asset->height))
1198 // printf("File::read_frame %d\n", __LINE__);
1199 // Can't advance position here because it needs to be added to cache
1202 if(!temp_frame->params_match(asset->width, asset->height, supported_colormodel))
1209 // printf("File::read_frame %d\n", __LINE__);
1212 temp_frame = new VFrame(0,
1216 supported_colormodel,
1220 // printf("File::read_frame %d\n", __LINE__);
1221 temp_frame->copy_stacks(frame);
1222 result = file->read_frame(temp_frame);
1224 frame->transfer_from(temp_frame);
1225 else if( result && frame->get_status() > 0 )
1226 frame->set_status(-1);
1227 //printf("File::read_frame %d\n", __LINE__);
1231 // Can't advance position here because it needs to be added to cache
1232 //printf("File::read_frame %d\n", __LINE__);
1233 result = file->read_frame(frame);
1234 if( result && frame->get_status() > 0 )
1235 frame->set_status(-1);
1236 //for(int i = 0; i < 100 * 1000; i++) ((float*)frame->get_rows()[0])[i] = 1.0;
1239 if( result && !current_frame )
1240 frame->clear_frame();
1242 if( cache_active && advance_position && frame->get_status() > 0 )
1243 frame_cache->put_frame(frame, cache_position,
1244 current_layer, asset->frame_rate, 1, 0);
1245 //printf("File::read_frame %d\n", __LINE__);
1247 if(advance_position) current_frame++;
1248 if(debug) PRINT_TRACE
1252 int File::can_copy_from(Asset *asset,
1257 if(!asset) return 0;
1261 return asset->width == output_w &&
1262 asset->height == output_h &&
1263 file->can_copy_from(asset, position);
1269 // Fill in queries about formats when adding formats here.
1272 int File::strtoformat(const char *format)
1274 return strtoformat(0, format);
1277 int File::strtoformat(ArrayList<PluginServer*> *plugindb, const char *format)
1279 if(!strcasecmp(format, _(AC3_NAME))) return FILE_AC3;
1280 if(!strcasecmp(format, _(SCENE_NAME))) return FILE_SCENE;
1281 if(!strcasecmp(format, _(WAV_NAME))) return FILE_WAV;
1282 if(!strcasecmp(format, _(PCM_NAME))) return FILE_PCM;
1283 if(!strcasecmp(format, _(AU_NAME))) return FILE_AU;
1284 if(!strcasecmp(format, _(AIFF_NAME))) return FILE_AIFF;
1285 if(!strcasecmp(format, _(SND_NAME))) return FILE_SND;
1286 if(!strcasecmp(format, _(PNG_NAME))) return FILE_PNG;
1287 if(!strcasecmp(format, _(PNG_LIST_NAME))) return FILE_PNG_LIST;
1288 if(!strcasecmp(format, _(TIFF_NAME))) return FILE_TIFF;
1289 if(!strcasecmp(format, _(TIFF_LIST_NAME))) return FILE_TIFF_LIST;
1290 if(!strcasecmp(format, _(JPEG_NAME))) return FILE_JPEG;
1291 if(!strcasecmp(format, _(JPEG_LIST_NAME))) return FILE_JPEG_LIST;
1292 if(!strcasecmp(format, _(EXR_NAME))) return FILE_EXR;
1293 if(!strcasecmp(format, _(EXR_LIST_NAME))) return FILE_EXR_LIST;
1294 if(!strcasecmp(format, _(FLAC_NAME))) return FILE_FLAC;
1295 if(!strcasecmp(format, _(CR2_NAME))) return FILE_CR2;
1296 if(!strcasecmp(format, _(CR2_LIST_NAME))) return FILE_CR2_LIST;
1297 if(!strcasecmp(format, _(MPEG_NAME))) return FILE_MPEG;
1298 if(!strcasecmp(format, _(AMPEG_NAME))) return FILE_AMPEG;
1299 if(!strcasecmp(format, _(VMPEG_NAME))) return FILE_VMPEG;
1300 if(!strcasecmp(format, _(TGA_NAME))) return FILE_TGA;
1301 if(!strcasecmp(format, _(TGA_LIST_NAME))) return FILE_TGA_LIST;
1302 if(!strcasecmp(format, _(OGG_NAME))) return FILE_OGG;
1303 if(!strcasecmp(format, _(VORBIS_NAME))) return FILE_VORBIS;
1304 if(!strcasecmp(format, _(RAWDV_NAME))) return FILE_RAWDV;
1305 if(!strcasecmp(format, _(FFMPEG_NAME))) return FILE_FFMPEG;
1306 if(!strcasecmp(format, _(DBASE_NAME))) return FILE_DB;
1312 const char* File::formattostr(int format)
1314 return formattostr(0, format);
1317 const char* File::formattostr(ArrayList<PluginServer*> *plugindb, int format)
1321 case FILE_SCENE: return _(SCENE_NAME);
1322 case FILE_AC3: return _(AC3_NAME);
1323 case FILE_WAV: return _(WAV_NAME);
1324 case FILE_PCM: return _(PCM_NAME);
1325 case FILE_AU: return _(AU_NAME);
1326 case FILE_AIFF: return _(AIFF_NAME);
1327 case FILE_SND: return _(SND_NAME);
1328 case FILE_PNG: return _(PNG_NAME);
1329 case FILE_PNG_LIST: return _(PNG_LIST_NAME);
1330 case FILE_JPEG: return _(JPEG_NAME);
1331 case FILE_JPEG_LIST: return _(JPEG_LIST_NAME);
1332 case FILE_CR2: return _(CR2_NAME);
1333 case FILE_CR2_LIST: return _(CR2_LIST_NAME);
1334 case FILE_FLAC: return _(FLAC_NAME);
1335 case FILE_EXR: return _(EXR_NAME);
1336 case FILE_EXR_LIST: return _(EXR_LIST_NAME);
1337 case FILE_MPEG: return _(MPEG_NAME);
1338 case FILE_AMPEG: return _(AMPEG_NAME);
1339 case FILE_VMPEG: return _(VMPEG_NAME);
1340 case FILE_TGA: return _(TGA_NAME);
1341 case FILE_TGA_LIST: return _(TGA_LIST_NAME);
1342 case FILE_TIFF: return _(TIFF_NAME);
1343 case FILE_TIFF_LIST: return _(TIFF_LIST_NAME);
1344 case FILE_OGG: return _(OGG_NAME);
1345 case FILE_VORBIS: return _(VORBIS_NAME);
1346 case FILE_RAWDV: return _(RAWDV_NAME);
1347 case FILE_FFMPEG: return _(FFMPEG_NAME);
1348 case FILE_DB: return _(DBASE_NAME);
1350 return _("Unknown");
1353 int File::strtobits(const char *bits)
1355 if(!strcasecmp(bits, _(NAME_8BIT))) return BITSLINEAR8;
1356 if(!strcasecmp(bits, _(NAME_16BIT))) return BITSLINEAR16;
1357 if(!strcasecmp(bits, _(NAME_24BIT))) return BITSLINEAR24;
1358 if(!strcasecmp(bits, _(NAME_32BIT))) return BITSLINEAR32;
1359 if(!strcasecmp(bits, _(NAME_ULAW))) return BITSULAW;
1360 if(!strcasecmp(bits, _(NAME_ADPCM))) return BITS_ADPCM;
1361 if(!strcasecmp(bits, _(NAME_FLOAT))) return BITSFLOAT;
1362 return BITSLINEAR16;
1365 const char* File::bitstostr(int bits)
1367 //printf("File::bitstostr\n");
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);
1378 return _("Unknown");
1383 int File::str_to_byteorder(const char *string)
1385 if(!strcasecmp(string, _("Lo Hi"))) return 1;
1389 const char* File::byteorder_to_str(int byte_order)
1391 if(byte_order) return _("Lo Hi");
1395 int File::bytes_per_sample(int bits)
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;
1412 int File::get_best_colormodel(int driver)
1414 return get_best_colormodel(asset, driver);
1417 int File::get_best_colormodel(Asset *asset, int driver)
1419 switch(asset->format)
1421 #ifdef HAVE_FIREWIRE
1422 case FILE_RAWDV: return FileDV::get_best_colormodel(asset, driver);
1424 case FILE_MPEG: return FileMPEG::get_best_colormodel(asset, driver);
1426 case FILE_JPEG_LIST: return FileJPEG::get_best_colormodel(asset, driver);
1428 case FILE_EXR_LIST: return FileEXR::get_best_colormodel(asset, driver);
1430 case FILE_PNG_LIST: return FilePNG::get_best_colormodel(asset, driver);
1432 case FILE_TGA_LIST: return FileTGA::get_best_colormodel(asset, driver);
1434 case FILE_CR2_LIST: return FileCR2::get_best_colormodel(asset, driver);
1435 case FILE_DB: return FileDB::get_best_colormodel(asset, driver);
1436 case FILE_FFMPEG: return FileFFMPEG::get_best_colormodel(asset, driver);
1443 int File::colormodel_supported(int colormodel)
1446 return file->colormodel_supported(colormodel);
1452 int64_t File::file_memory_usage()
1454 return file ? file->base_memory_usage() : 0;
1457 int64_t File::get_memory_usage()
1461 result += file_memory_usage();
1462 if(temp_frame) result += temp_frame->get_data_size();
1463 result += frame_cache->get_memory_usage();
1464 if(video_thread) result += video_thread->get_memory_usage();
1466 if(result < MIN_CACHEITEM_SIZE) result = MIN_CACHEITEM_SIZE;
1471 int File::supports_video(ArrayList<PluginServer*> *plugindb, char *format)
1473 int format_i = strtoformat(plugindb, format);
1475 return supports_video(format_i);
1479 int File::supports_audio(ArrayList<PluginServer*> *plugindb, char *format)
1481 int format_i = strtoformat(plugindb, format);
1483 return supports_audio(format_i);
1488 int File::supports_video(int format)
1490 //printf("File::supports_video %d\n", format);
1495 case FILE_JPEG_LIST:
1505 case FILE_TIFF_LIST:
1514 int File::supports_audio(int format)
1535 const char* File::get_tag(int format)
1539 case FILE_AC3: return "ac3";
1540 case FILE_AIFF: return "aif";
1541 case FILE_AMPEG: return "mp3";
1542 case FILE_AU: return "au";
1543 case FILE_RAWDV: return "dv";
1544 case FILE_DB: return "db";
1545 case FILE_EXR: return "exr";
1546 case FILE_EXR_LIST: return "exr";
1547 case FILE_FLAC: return "flac";
1548 case FILE_JPEG: return "jpg";
1549 case FILE_JPEG_LIST: return "jpg";
1550 case FILE_OGG: return "ogg";
1551 case FILE_PCM: return "pcm";
1552 case FILE_PNG: return "png";
1553 case FILE_PNG_LIST: return "png";
1554 case FILE_TGA: return "tga";
1555 case FILE_TGA_LIST: return "tga";
1556 case FILE_TIFF: return "tif";
1557 case FILE_TIFF_LIST: return "tif";
1558 case FILE_VMPEG: return "m2v";
1559 case FILE_VORBIS: return "ogg";
1560 case FILE_WAV: return "wav";
1561 case FILE_FFMPEG: return "ffmpg";
1566 const char* File::get_prefix(int format)
1569 case FILE_PCM: return "PCM";
1570 case FILE_WAV: return "WAV";
1571 case FILE_PNG: return "PNG";
1572 case FILE_JPEG: return "JPEG";
1573 case FILE_TIFF: return "TIFF";
1574 case FILE_GIF: return "GIF";
1575 case FILE_JPEG_LIST: return "JPEG_LIST";
1576 case FILE_AU: return "AU";
1577 case FILE_AIFF: return "AIFF";
1578 case FILE_SND: return "SND";
1579 case FILE_TGA_LIST: return "TGA_LIST";
1580 case FILE_TGA: return "TGA";
1581 case FILE_MPEG: return "MPEG";
1582 case FILE_AMPEG: return "AMPEG";
1583 case FILE_VMPEG: return "VMPEG";
1584 case FILE_RAWDV: return "RAWDV";
1585 case FILE_TIFF_LIST: return "TIFF_LIST";
1586 case FILE_PNG_LIST: return "PNG_LIST";
1587 case FILE_AC3: return "AC3";
1588 case FILE_EXR: return "EXR";
1589 case FILE_EXR_LIST: return "EXR_LIST";
1590 case FILE_CR2: return "CR2";
1591 case FILE_OGG: return "OGG";
1592 case FILE_VORBIS: return "VORBIS";
1593 case FILE_FLAC: return "FLAC";
1594 case FILE_FFMPEG: return "FFMPEG";
1595 case FILE_SCENE: return "SCENE";
1596 case FILE_CR2_LIST: return "CR2_LIST";
1597 case FILE_GIF_LIST: return "GIF_LIST";
1598 case FILE_DB: return "DB";
1600 return _("UNKNOWN");
1604 PackagingEngine *File::new_packaging_engine(Asset *asset)
1606 PackagingEngine *result;
1607 switch (asset->format)
1610 result = (PackagingEngine*)new PackagingEngineOGG();
1613 result = (PackagingEngine*) new PackagingEngineDefault();
1621 int File::record_fd()
1623 return file ? file->record_fd() : -1;
1627 void File::get_exe_path(char *result, char *bnp)
1629 // Get executable path, basename
1630 int len = readlink("/proc/self/exe", result, BCTEXTLEN-1);
1633 char *ptr = strrchr(result, '/');
1634 if( ptr ) *ptr++ = 0; else ptr = result;
1635 if( bnp ) strncpy(bnp, ptr, BCTEXTLEN);
1643 void File::getenv_path(char *result, const char *path)
1645 char *rp = result, *ep = rp + BCTEXTLEN-1;
1646 const char *cp = path;
1647 // any env var can be used here to expand a path as:
1648 // "path...$id...": and id is a word as alpha,alnum...
1649 // expands as "path...getenv(id)..."
1650 // CIN_PATH, CIN_LIB are set in main.C,
1651 for( int ch=*cp++; ch && rp < ep; ch=*cp++ ) {
1652 if( ch == '$' && isalpha(*cp) ) { // scan alpha,alnum...
1653 const char *bp = cp; char *p = rp;
1654 while( p < ep && *bp && (isalnum(*bp) || *bp == '_') ) *p++ = *bp++;
1656 const char *envp = getenv(rp); // read env value
1657 if( !envp ) continue;
1658 while( *envp && rp < ep ) *rp++ = *envp++;
1659 cp = bp; // subst id=value
1667 char File::cinexe_path[BCTEXTLEN];
1668 char File::cinpkg_path[BCTEXTLEN];
1669 char File::cindat_path[BCTEXTLEN];
1670 char File::cinlib_path[BCTEXTLEN];
1671 char File::cincfg_path[BCTEXTLEN];
1672 char File::cinplg_path[BCTEXTLEN];
1673 char File::cinlad_path[BCTEXTLEN];
1674 char File::cinlcl_path[BCTEXTLEN];
1676 void File::init_cin_path()
1678 char env_path[BCTEXTLEN], env_pkg[BCTEXTLEN];
1679 // these values are advertised for forks/shell scripts
1680 get_exe_path(env_path, env_pkg);
1681 snprintf(cinexe_path, sizeof(cinexe_path), "CIN_PATH=%s", env_path);
1682 putenv(cinexe_path);
1683 snprintf(cinpkg_path, sizeof(cinpkg_path), "CIN_PKG=%s", env_pkg);
1684 putenv(cinpkg_path);
1686 getenv_path(env_path, CINDAT_DIR);
1687 snprintf(cindat_path, sizeof(cindat_path), "CIN_DAT=%s", env_path);
1688 putenv(cindat_path);
1690 getenv_path(env_path, CINLIB_DIR);
1691 snprintf(cinlib_path, sizeof(cinlib_path), "CIN_LIB=%s", env_path);
1692 putenv(cinlib_path);
1694 getenv_path(env_path, CONFIG_DIR);
1695 snprintf(cincfg_path, sizeof(cincfg_path), "CIN_CONFIG=%s", env_path);
1696 putenv(cincfg_path);
1698 getenv_path(env_path, PLUGIN_DIR);
1699 snprintf(cinplg_path, sizeof(cinplg_path), "CIN_PLUGIN=%s", env_path);
1700 putenv(cinplg_path);
1702 getenv_path(env_path, LADSPA_DIR);
1703 snprintf(cinlad_path, sizeof(cinlad_path), "CIN_LADSPA=%s", env_path);
1704 putenv(cinlad_path);
1706 getenv_path(env_path, LOCALE_DIR);
1707 snprintf(cinlcl_path, sizeof(cinlcl_path), "CIN_LOCALE=%s", env_path);
1708 putenv(cinlcl_path);