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"
70 #include "packagingengine.h"
71 #include "pluginserver.h"
72 #include "preferences.h"
76 //suppress noref warning
77 void *vorbis0_ov_callbacks[] = {
78 &OV_CALLBACKS_DEFAULT, &OV_CALLBACKS_NOCLOSE,
79 &OV_CALLBACKS_STREAMONLY, &OV_CALLBACKS_STREAMONLY_NOCLOSE,
86 format_completion = new Condition(1, "File::format_completion");
87 write_lock = new Condition(1, "File::write_lock");
88 frame_cache = new FrameCache;
96 if(format_window) format_window->set_done(0);
97 format_completion->lock("File::~File");
98 format_completion->unlock();
101 if(temp_frame) delete temp_frame;
106 asset->Garbage::remove_user();
107 delete format_completion;
112 void File::reset_parameters()
125 normalized_sample = 0;
128 playback_subtitle = -1;
132 temp_samples_buffer = 0;
133 temp_frame_buffer = 0;
134 current_frame_buffer = 0;
135 audio_ring_buffers = 0;
136 video_ring_buffers = 0;
137 video_buffer_size = 0;
140 int File::raise_window()
142 if(getting_options && format_window)
144 format_window->raise_window();
145 format_window->flush();
150 void File::close_window()
154 format_window->lock_window("File::close_window");
155 format_window->set_done(1);
156 format_window->unlock_window();
161 int File::get_options(FormatTools *format,
162 int audio_options, int video_options)
164 BC_WindowBase *parent_window = format->window;
165 //ArrayList<PluginServer*> *plugindb = format->plugindb;
166 Asset *asset = format->asset;
169 format_completion->lock("File::get_options");
170 switch(asset->format)
173 FileAC3::get_parameters(parent_window,
180 FileDV::get_parameters(parent_window,
191 FileSndFile::get_parameters(parent_window,
198 FileFFMPEG::get_parameters(parent_window,
206 FileMPEG::get_parameters(parent_window,
214 FileJPEG::get_parameters(parent_window,
222 FileEXR::get_parameters(parent_window,
229 FileFLAC::get_parameters(parent_window,
237 FilePNG::get_parameters(parent_window,
245 FileTGA::get_parameters(parent_window,
253 FileTIFF::get_parameters(parent_window,
260 FileOGG::get_parameters(parent_window,
272 ErrorBox *errorbox = new ErrorBox(_(PROGRAM_NAME ": Error"),
273 parent_window->get_abs_cursor_x(1),
274 parent_window->get_abs_cursor_y(1));
275 format_window = errorbox;
278 errorbox->create_objects(_("This format doesn't support audio."));
281 errorbox->create_objects(_("This format doesn't support video."));
282 errorbox->run_window();
288 format_completion->unlock();
301 int File::set_processors(int cpus) // Set the number of cpus for certain codecs
303 if( cpus > 8 ) // mpegvideo max_threads = 16, more causes errs
304 cpus = 8; // 8 cpus ought to decode just about anything
305 // Set all instances so gets work.
311 int File::set_preload(int64_t size)
313 this->playback_preload = size;
317 void File::set_subtitle(int value)
319 this->playback_subtitle = value;
320 if( file ) file->set_subtitle(value);
323 void File::set_interpolate_raw(int value)
325 this->interpolate_raw = value;
328 void File::set_white_balance_raw(int value)
330 this->white_balance_raw = value;
334 void File::set_cache_frames(int value)
336 // caching only done locally
341 int File::purge_cache()
343 // caching only done locally
345 if( frame_cache->cache_items() > 0 )
347 frame_cache->remove_all();
353 int File::delete_oldest()
355 // caching only done locally
356 return frame_cache->delete_oldest();
369 int File::open_file(Preferences *preferences,
376 this->preferences = preferences;
377 this->asset->copy_from(asset, 1);
382 if(debug) printf("File::open_file %d\n", __LINE__);
384 if(debug) printf("File::open_file %p %d\n", this, __LINE__);
386 switch(this->asset->format)
388 // get the format now
389 // If you add another format to case 0, you also need to add another case for the
390 // file format #define.
392 if(FileDB::check_sig(this->asset)) {
394 file = new FileDB(this->asset, this);
397 // if early probe enabled
398 if( preferences->ffmpeg_early_probe &&
399 FileFFMPEG::check_sig(this->asset)) {
400 file = new FileFFMPEG(this->asset, this);
405 if(!(stream = fopen(this->asset->path, "rb"))) {
410 char test[16]; memset(test,0,sizeof(test)); // int result =
411 fread(test, 16, 1, stream);
413 if(FileScene::check_sig(this->asset, test)) {
416 file = new FileScene(this->asset, this);
419 if(FileDV::check_sig(this->asset)) {
422 file = new FileDV(this->asset, this);
425 if(FileSndFile::check_sig(this->asset)) {
428 file = new FileSndFile(this->asset, this);
431 if(FilePNG::check_sig(this->asset)) {
434 file = new FilePNG(this->asset, this);
437 if(FileJPEG::check_sig(this->asset)) {
440 file = new FileJPEG(this->asset, this);
443 if(FileGIF::check_sig(this->asset)) {
446 file = new FileGIF(this->asset, this);
449 if(FileEXR::check_sig(this->asset, test)) {
452 file = new FileEXR(this->asset, this);
455 if(FileFLAC::check_sig(this->asset, test)) {
458 file = new FileFLAC(this->asset, this);
461 if(FileCR2::check_sig(this->asset)) {
464 file = new FileCR2(this->asset, this);
467 if(FileTGA::check_sig(this->asset)) {
470 file = new FileTGA(this->asset, this);
473 if(FileTIFF::check_sig(this->asset)) {
476 file = new FileTIFF(this->asset, this);
479 if(FileOGG::check_sig(this->asset)) {
482 file = new FileOGG(this->asset, this);
485 if(FileVorbis::check_sig(this->asset)) {
488 file = new FileVorbis(this->asset, this);
491 if(FileMPEG::check_sig(this->asset)) {
494 file = new FileMPEG(this->asset, this);
497 if( test[0] == '<' && (
498 !strncmp(&test[1],"EDL>",4) ||
499 !strncmp(&test[1],"HTAL>",5) ||
500 !strncmp(&test[1],"?xml",4) ) ) {
504 } // can't load project file
505 if( !preferences->ffmpeg_early_probe &&
506 FileFFMPEG::check_sig(this->asset) ) {
508 file = new FileFFMPEG(this->asset, this);
513 return FILE_UNRECOGNIZED_CODEC;
516 // format already determined
518 file = new FileAC3(this->asset, this);
522 file = new FileScene(this->asset, this);
526 file = new FileFFMPEG(this->asset, this);
534 //printf("File::open_file 1\n");
535 file = new FileSndFile(this->asset, this);
540 file = new FilePNG(this->asset, this);
545 file = new FileJPEG(this->asset, this);
550 file = new FileGIF(this->asset, this);
555 file = new FileEXR(this->asset, this);
559 file = new FileFLAC(this->asset, this);
564 file = new FileCR2(this->asset, this);
569 file = new FileTGA(this->asset, this);
574 file = new FileTIFF(this->asset, this);
578 file = new FileDB(this->asset, this);
584 file = new FileMPEG(this->asset, this);
588 file = new FileOGG(this->asset, this);
592 file = new FileVorbis(this->asset, this);
596 file = new FileDV(this->asset, this);
606 // Reopen file with correct parser and get header.
607 if(file->open_file(rd, wr)) {
608 delete file; file = 0;
609 return FILE_NOT_FOUND;
614 // Set extra writing parameters to mandatory settings.
616 if(this->asset->dither) file->set_dither();
620 // one frame image file, no specific length
621 if( !this->asset->audio_data && this->asset->video_data &&
622 this->asset->video_length <= 1 )
623 this->asset->video_length = -1;
626 // Synchronize header parameters
627 asset->copy_from(this->asset, 1);
630 if(debug) printf("File::open_file %d file=%p\n", __LINE__, file);
636 void File::delete_temp_samples_buffer()
639 if(temp_samples_buffer) {
640 for(int j = 0; j < audio_ring_buffers; j++) {
641 for(int i = 0; i < asset->channels; i++) {
642 delete temp_samples_buffer[j][i];
644 delete [] temp_samples_buffer[j];
647 delete [] temp_samples_buffer;
648 temp_samples_buffer = 0;
649 audio_ring_buffers = 0;
653 void File::delete_temp_frame_buffer()
656 if(temp_frame_buffer) {
657 for(int k = 0; k < video_ring_buffers; k++) {
658 for(int i = 0; i < asset->layers; i++) {
659 for(int j = 0; j < video_buffer_size; j++) {
660 delete temp_frame_buffer[k][i][j];
662 delete [] temp_frame_buffer[k][i];
664 delete [] temp_frame_buffer[k];
667 delete [] temp_frame_buffer;
668 temp_frame_buffer = 0;
669 video_ring_buffers = 0;
670 video_buffer_size = 0;
674 int File::close_file(int ignore_thread)
678 if(debug) printf("File::close_file file=%p %d\n", file, __LINE__);
686 if(debug) printf("File::close_file file=%p %d\n", file, __LINE__);
688 // The file's asset is a copy of the argument passed to open_file so the
689 // user must copy lengths from the file's asset.
691 asset->audio_length = current_sample;
692 asset->video_length = current_frame;
698 if(debug) printf("File::close_file file=%p %d\n", file, __LINE__);
700 delete_temp_samples_buffer();
701 delete_temp_frame_buffer();
702 if(debug) printf("File::close_file file=%p %d\n", file, __LINE__);
704 if(debug) printf("File::close_file file=%p %d\n", file, __LINE__);
707 if(debug) printf("File::close_file file=%p %d\n", file, __LINE__);
713 int File::get_index(char *index_path)
716 return file->get_index(index_path);
723 int File::start_audio_thread(int buffer_size, int ring_buffers)
725 this->audio_ring_buffers = ring_buffers;
730 audio_thread = new FileThread(this, 1, 0);
731 audio_thread->start_writing(buffer_size, 0, ring_buffers, 0);
736 int File::start_video_thread(int buffer_size,
741 this->video_ring_buffers = ring_buffers;
742 this->video_buffer_size = buffer_size;
746 video_thread = new FileThread(this, 0, 1);
747 video_thread->start_writing(buffer_size,
755 int File::start_video_decode_thread()
757 // Currently, CR2 is the only one which won't work asynchronously, so
758 // we're not using a virtual function yet.
759 if(!video_thread /* && asset->format != FILE_CR2 */)
761 video_thread = new FileThread(this, 0, 1);
762 video_thread->start_reading();
768 int File::stop_audio_thread()
772 audio_thread->stop_writing();
779 int File::stop_video_thread()
783 video_thread->stop_reading();
784 video_thread->stop_writing();
791 FileThread* File::get_video_thread()
796 int File::set_channel(int channel)
798 if(file && channel < asset->channels)
800 current_channel = channel;
807 int File::get_channel()
809 return current_channel;
812 // if no>=0, sets new program
813 // returns current program
814 int File::set_program(int no)
816 int result = file ? file->set_program(no) : current_program;
817 current_program = no < 0 ? result : no;
821 int File::get_cell_time(int no, double &time)
823 return file ? file->get_cell_time(no, time) : -1;
826 int File::get_system_time(int64_t &tm)
828 return file ? file->get_system_time(tm) : -1;
831 int File::get_audio_for_video(int vstream, int astream, int64_t &channel_mask)
833 return file ? file->get_audio_for_video(vstream, astream, channel_mask) : -1;
836 int File::get_video_pid(int track)
838 return file ? file->get_video_pid(track) : -1;
843 int File::get_video_info(int track, int &pid, double &framerate,
844 int &width, int &height, char *title)
847 file->get_video_info(track, pid, framerate, width, height, title);
850 int File::select_video_stream(Asset *asset, int vstream)
853 file->select_video_stream(asset, vstream);
856 int File::select_audio_stream(Asset *asset, int astream)
859 file->select_audio_stream(asset, astream);
863 int File::get_thumbnail(int stream,
864 int64_t &position, unsigned char *&thumbnail, int &ww, int &hh)
866 return file->get_thumbnail(stream, position, thumbnail, ww, hh);
869 int File::set_skimming(int track, int skim, skim_fn fn, void *vp)
871 return file->set_skimming(track, skim, fn, vp);
874 int File::skim_video(int track, void *vp, skim_fn fn)
876 return file->skim_video(track, vp, fn);
880 int File::set_layer(int layer, int is_thread)
882 if(file && layer < asset->layers)
884 if(!is_thread && video_thread)
886 video_thread->set_layer(layer);
890 current_layer = layer;
898 int64_t File::get_audio_length()
900 int64_t result = asset->audio_length;
901 int64_t base_samplerate = -1;
904 if(base_samplerate > 0)
905 return (int64_t)((double)result / asset->sample_rate * base_samplerate + 0.5);
913 int64_t File::get_video_length()
915 int64_t result = asset->video_length;
916 float base_framerate = -1;
919 if(base_framerate > 0)
920 return (int64_t)((double)result / asset->frame_rate * base_framerate + 0.5);
925 return -1; // infinity
929 int64_t File::get_video_position()
931 float base_framerate = -1;
932 if(base_framerate > 0)
933 return (int64_t)((double)current_frame / asset->frame_rate * base_framerate + 0.5);
935 return current_frame;
938 int64_t File::get_audio_position()
940 // int64_t base_samplerate = -1;
941 // if(base_samplerate > 0)
943 // if(normalized_sample_rate == base_samplerate)
944 // return normalized_sample;
946 // return (int64_t)((double)current_sample /
947 // asset->sample_rate *
952 return current_sample;
957 int File::set_audio_position(int64_t position)
963 #define REPOSITION(x, y) \
964 (labs((x) - (y)) > 1)
966 float base_samplerate = asset->sample_rate;
967 current_sample = normalized_sample = position;
969 // printf("File::set_audio_position %d normalized_sample=%ld\n",
971 // normalized_sample);
972 result = file->set_audio_position(current_sample);
975 printf("File::set_audio_position position=%jd"
976 " base_samplerate=%f asset=%p asset->sample_rate=%d\n",
977 position, base_samplerate, asset, asset->sample_rate);
979 //printf("File::set_audio_position %d %d %d\n", current_channel, current_sample, position);
984 int File::set_video_position(int64_t position,
990 // Convert to file's rate
991 // if(base_framerate > 0)
992 // position = (int64_t)((double)position /
994 // asset->frame_rate +
998 if(video_thread && !is_thread)
1000 // Call thread. Thread calls this again to set the file state.
1001 video_thread->set_video_position(position);
1004 if(current_frame != position)
1008 current_frame = position;
1009 result = file->set_video_position(current_frame);
1016 // No resampling here.
1017 int File::write_samples(Samples **buffer, int64_t len)
1023 write_lock->lock("File::write_samples");
1025 // Convert to arrays for backwards compatability
1026 double *temp[asset->channels];
1027 for(int i = 0; i < asset->channels; i++)
1029 temp[i] = buffer[i]->get_data();
1032 result = file->write_samples(temp, len);
1033 current_sample += len;
1034 normalized_sample += len;
1035 asset->audio_length += len;
1036 write_lock->unlock();
1045 // Can't put any cmodel abstraction here because the filebase couldn't be
1047 int File::write_frames(VFrame ***frames, int len)
1049 //printf("File::write_frames %d\n", __LINE__);
1051 // Store the counters in temps so the filebase can choose to overwrite them.
1053 int current_frame_temp = current_frame;
1054 int video_length_temp = asset->video_length;
1056 write_lock->lock("File::write_frames");
1059 result = file->write_frames(frames, len);
1062 current_frame = current_frame_temp + len;
1063 asset->video_length = video_length_temp + len;
1064 write_lock->unlock();
1069 // Only called by FileThread
1070 int File::write_compressed_frame(VFrame *buffer)
1073 write_lock->lock("File::write_compressed_frame");
1074 result = file->write_compressed_frame(buffer);
1076 asset->video_length++;
1077 write_lock->unlock();
1082 int File::write_audio_buffer(int64_t len)
1087 result = audio_thread->write_buffer(len);
1092 int File::write_video_buffer(int64_t len)
1097 result = video_thread->write_buffer(len);
1103 Samples** File::get_audio_buffer()
1105 if(audio_thread) return audio_thread->get_audio_buffer();
1109 VFrame*** File::get_video_buffer()
1113 VFrame*** result = video_thread->get_video_buffer();
1122 int File::read_samples(Samples *samples, int64_t len)
1124 // Never try to read more samples than exist in the file
1125 if (current_sample + len > asset->audio_length) {
1126 len = asset->audio_length - current_sample;
1128 if(len <= 0) return 0;
1131 const int debug = 0;
1132 if(debug) PRINT_TRACE
1134 if(debug) PRINT_TRACE
1136 double *buffer = samples->get_data();
1138 int64_t base_samplerate = asset->sample_rate;
1142 // Resample recursively calls this with the asset sample rate
1143 if(base_samplerate == 0) base_samplerate = asset->sample_rate;
1145 if(debug) PRINT_TRACE
1146 result = file->read_samples(buffer, len);
1148 if(debug) PRINT_TRACE
1149 current_sample += len;
1151 normalized_sample += len;
1153 if(debug) PRINT_TRACE
1158 int File::read_frame(VFrame *frame, int is_thread)
1160 const int debug = 0;
1162 if(debug) PRINT_TRACE
1164 //printf("File::read_frame %d\n", __LINE__);
1166 if(video_thread && !is_thread) return video_thread->read_frame(frame);
1168 //printf("File::read_frame %d\n", __LINE__);
1169 if(debug) PRINT_TRACE
1170 if( !file ) return 1;
1171 if(debug) PRINT_TRACE
1172 int supported_colormodel = colormodel_supported(frame->get_color_model());
1173 int advance_position = 1;
1177 frame_cache->get_frame(frame,
1182 // Can't advance position if cache used.
1183 //printf("File::read_frame %d\n", __LINE__);
1184 advance_position = 0;
1187 else if(frame->get_color_model() != BC_COMPRESSED &&
1188 (supported_colormodel != frame->get_color_model() ||
1189 frame->get_w() != asset->width ||
1190 frame->get_h() != asset->height))
1193 // printf("File::read_frame %d\n", __LINE__);
1194 // Can't advance position here because it needs to be added to cache
1197 if(!temp_frame->params_match(asset->width, asset->height, supported_colormodel))
1204 // printf("File::read_frame %d\n", __LINE__);
1207 temp_frame = new VFrame(0,
1211 supported_colormodel,
1215 // printf("File::read_frame %d\n", __LINE__);
1216 temp_frame->copy_stacks(frame);
1217 int result = file->read_frame(temp_frame);
1218 if( result && frame->get_status() > 0 )
1219 frame->set_status(-1);
1220 //for(int i = 0; i < 1000 * 1000; i++) ((float*)temp_frame->get_rows()[0])[i] = 1.0;
1221 // printf("File::read_frame %d %d %d %d %d %d\n",
1222 // temp_frame->get_color_model(),
1223 // temp_frame->get_w(),
1224 // temp_frame->get_h(),
1225 // frame->get_color_model(),
1228 BC_CModels::transfer(frame->get_rows(), temp_frame->get_rows(),
1229 frame->get_y(), frame->get_u(), frame->get_v(),
1230 temp_frame->get_y(), temp_frame->get_u(), temp_frame->get_v(),
1231 0, 0, temp_frame->get_w(), temp_frame->get_h(),
1232 0, 0, frame->get_w(), frame->get_h(),
1233 temp_frame->get_color_model(),
1234 frame->get_color_model(), 0, temp_frame->get_w(),
1236 // printf("File::read_frame %d\n", __LINE__);
1240 // Can't advance position here because it needs to be added to cache
1241 //printf("File::read_frame %d\n", __LINE__);
1242 int result = file->read_frame(frame);
1243 if( result && frame->get_status() > 0 )
1244 frame->set_status(-1);
1245 //for(int i = 0; i < 100 * 1000; i++) ((float*)frame->get_rows()[0])[i] = 1.0;
1248 //printf("File::read_frame %d use_cache=%d\n", __LINE__, use_cache);
1250 frame_cache->put_frame(frame,
1251 current_frame, current_layer,
1252 asset->frame_rate, 1, 0);
1253 //printf("File::read_frame %d\n", __LINE__);
1255 if(advance_position) current_frame++;
1256 if(debug) PRINT_TRACE
1260 int File::can_copy_from(Asset *asset,
1265 if(!asset) return 0;
1269 return asset->width == output_w &&
1270 asset->height == output_h &&
1271 file->can_copy_from(asset, position);
1277 // Fill in queries about formats when adding formats here.
1280 int File::strtoformat(const char *format)
1282 return strtoformat(0, format);
1285 int File::strtoformat(ArrayList<PluginServer*> *plugindb, const char *format)
1287 if(!strcasecmp(format, _(AC3_NAME))) return FILE_AC3;
1288 if(!strcasecmp(format, _(SCENE_NAME))) return FILE_SCENE;
1289 if(!strcasecmp(format, _(WAV_NAME))) return FILE_WAV;
1290 if(!strcasecmp(format, _(PCM_NAME))) return FILE_PCM;
1291 if(!strcasecmp(format, _(AU_NAME))) return FILE_AU;
1292 if(!strcasecmp(format, _(AIFF_NAME))) return FILE_AIFF;
1293 if(!strcasecmp(format, _(SND_NAME))) return FILE_SND;
1294 if(!strcasecmp(format, _(PNG_NAME))) return FILE_PNG;
1295 if(!strcasecmp(format, _(PNG_LIST_NAME))) return FILE_PNG_LIST;
1296 if(!strcasecmp(format, _(TIFF_NAME))) return FILE_TIFF;
1297 if(!strcasecmp(format, _(TIFF_LIST_NAME))) return FILE_TIFF_LIST;
1298 if(!strcasecmp(format, _(JPEG_NAME))) return FILE_JPEG;
1299 if(!strcasecmp(format, _(JPEG_LIST_NAME))) return FILE_JPEG_LIST;
1300 if(!strcasecmp(format, _(EXR_NAME))) return FILE_EXR;
1301 if(!strcasecmp(format, _(EXR_LIST_NAME))) return FILE_EXR_LIST;
1302 if(!strcasecmp(format, _(FLAC_NAME))) return FILE_FLAC;
1303 if(!strcasecmp(format, _(CR2_NAME))) return FILE_CR2;
1304 if(!strcasecmp(format, _(CR2_LIST_NAME))) return FILE_CR2_LIST;
1305 if(!strcasecmp(format, _(MPEG_NAME))) return FILE_MPEG;
1306 if(!strcasecmp(format, _(AMPEG_NAME))) return FILE_AMPEG;
1307 if(!strcasecmp(format, _(VMPEG_NAME))) return FILE_VMPEG;
1308 if(!strcasecmp(format, _(TGA_NAME))) return FILE_TGA;
1309 if(!strcasecmp(format, _(TGA_LIST_NAME))) return FILE_TGA_LIST;
1310 if(!strcasecmp(format, _(OGG_NAME))) return FILE_OGG;
1311 if(!strcasecmp(format, _(VORBIS_NAME))) return FILE_VORBIS;
1312 if(!strcasecmp(format, _(RAWDV_NAME))) return FILE_RAWDV;
1313 if(!strcasecmp(format, _(FFMPEG_NAME))) return FILE_FFMPEG;
1314 if(!strcasecmp(format, _(DBASE_NAME))) return FILE_DB;
1320 const char* File::formattostr(int format)
1322 return formattostr(0, format);
1325 const char* File::formattostr(ArrayList<PluginServer*> *plugindb, int format)
1329 case FILE_SCENE: return _(SCENE_NAME);
1330 case FILE_AC3: return _(AC3_NAME);
1331 case FILE_WAV: return _(WAV_NAME);
1332 case FILE_PCM: return _(PCM_NAME);
1333 case FILE_AU: return _(AU_NAME);
1334 case FILE_AIFF: return _(AIFF_NAME);
1335 case FILE_SND: return _(SND_NAME);
1336 case FILE_PNG: return _(PNG_NAME);
1337 case FILE_PNG_LIST: return _(PNG_LIST_NAME);
1338 case FILE_JPEG: return _(JPEG_NAME);
1339 case FILE_JPEG_LIST: return _(JPEG_LIST_NAME);
1340 case FILE_CR2: return _(CR2_NAME);
1341 case FILE_CR2_LIST: return _(CR2_LIST_NAME);
1342 case FILE_FLAC: return _(FLAC_NAME);
1343 case FILE_EXR: return _(EXR_NAME);
1344 case FILE_EXR_LIST: return _(EXR_LIST_NAME);
1345 case FILE_MPEG: return _(MPEG_NAME);
1346 case FILE_AMPEG: return _(AMPEG_NAME);
1347 case FILE_VMPEG: return _(VMPEG_NAME);
1348 case FILE_TGA: return _(TGA_NAME);
1349 case FILE_TGA_LIST: return _(TGA_LIST_NAME);
1350 case FILE_TIFF: return _(TIFF_NAME);
1351 case FILE_TIFF_LIST: return _(TIFF_LIST_NAME);
1352 case FILE_OGG: return _(OGG_NAME);
1353 case FILE_VORBIS: return _(VORBIS_NAME);
1354 case FILE_RAWDV: return _(RAWDV_NAME);
1355 case FILE_FFMPEG: return _(FFMPEG_NAME);
1356 case FILE_DB: return _(DBASE_NAME);
1358 return _("Unknown");
1361 int File::strtobits(const char *bits)
1363 if(!strcasecmp(bits, _(NAME_8BIT))) return BITSLINEAR8;
1364 if(!strcasecmp(bits, _(NAME_16BIT))) return BITSLINEAR16;
1365 if(!strcasecmp(bits, _(NAME_24BIT))) return BITSLINEAR24;
1366 if(!strcasecmp(bits, _(NAME_32BIT))) return BITSLINEAR32;
1367 if(!strcasecmp(bits, _(NAME_ULAW))) return BITSULAW;
1368 if(!strcasecmp(bits, _(NAME_ADPCM))) return BITS_ADPCM;
1369 if(!strcasecmp(bits, _(NAME_FLOAT))) return BITSFLOAT;
1370 return BITSLINEAR16;
1373 const char* File::bitstostr(int bits)
1375 //printf("File::bitstostr\n");
1378 case BITSLINEAR8: return (NAME_8BIT);
1379 case BITSLINEAR16: return (NAME_16BIT);
1380 case BITSLINEAR24: return (NAME_24BIT);
1381 case BITSLINEAR32: return (NAME_32BIT);
1382 case BITSULAW: return (NAME_ULAW);
1383 case BITS_ADPCM: return (NAME_ADPCM);
1384 case BITSFLOAT: return (NAME_FLOAT);
1386 return _("Unknown");
1391 int File::str_to_byteorder(const char *string)
1393 if(!strcasecmp(string, _("Lo Hi"))) return 1;
1397 const char* File::byteorder_to_str(int byte_order)
1399 if(byte_order) return _("Lo Hi");
1403 int File::bytes_per_sample(int bits)
1407 case BITSLINEAR8: return 1;
1408 case BITSLINEAR16: return 2;
1409 case BITSLINEAR24: return 3;
1410 case BITSLINEAR32: return 4;
1411 case BITSULAW: return 1;
1420 int File::get_best_colormodel(int driver)
1422 return get_best_colormodel(asset, driver);
1425 int File::get_best_colormodel(Asset *asset, int driver)
1427 switch(asset->format)
1429 case FILE_RAWDV: return FileDV::get_best_colormodel(asset, driver);
1430 case FILE_MPEG: return FileMPEG::get_best_colormodel(asset, driver);
1432 case FILE_JPEG_LIST: return FileJPEG::get_best_colormodel(asset, driver);
1434 case FILE_EXR_LIST: return FileEXR::get_best_colormodel(asset, driver);
1436 case FILE_PNG_LIST: return FilePNG::get_best_colormodel(asset, driver);
1438 case FILE_TGA_LIST: return FileTGA::get_best_colormodel(asset, driver);
1440 case FILE_CR2_LIST: return FileCR2::get_best_colormodel(asset, driver);
1441 case FILE_DB: return FileDB::get_best_colormodel(asset, driver);
1448 int File::colormodel_supported(int colormodel)
1451 return file->colormodel_supported(colormodel);
1457 int64_t File::file_memory_usage()
1459 return file ? file->base_memory_usage() : 0;
1462 int64_t File::get_memory_usage()
1466 result += file_memory_usage();
1467 if(temp_frame) result += temp_frame->get_data_size();
1468 result += frame_cache->get_memory_usage();
1469 if(video_thread) result += video_thread->get_memory_usage();
1471 if(result < MIN_CACHEITEM_SIZE) result = MIN_CACHEITEM_SIZE;
1476 int File::supports_video(ArrayList<PluginServer*> *plugindb, char *format)
1478 int format_i = strtoformat(plugindb, format);
1480 return supports_video(format_i);
1484 int File::supports_audio(ArrayList<PluginServer*> *plugindb, char *format)
1486 int format_i = strtoformat(plugindb, format);
1488 return supports_audio(format_i);
1493 int File::supports_video(int format)
1495 //printf("File::supports_video %d\n", format);
1500 case FILE_JPEG_LIST:
1510 case FILE_TIFF_LIST:
1519 int File::supports_audio(int format)
1539 const char* File::get_tag(int format)
1543 case FILE_AC3: return "ac3";
1544 case FILE_AIFF: return "aif";
1545 case FILE_AMPEG: return "mp3";
1546 case FILE_AU: return "au";
1547 case FILE_RAWDV: return "dv";
1548 case FILE_DB: return "db";
1549 case FILE_EXR: return "exr";
1550 case FILE_EXR_LIST: return "exr";
1551 case FILE_FLAC: return "flac";
1552 case FILE_JPEG: return "jpg";
1553 case FILE_JPEG_LIST: return "jpg";
1554 case FILE_OGG: return "ogg";
1555 case FILE_PCM: return "pcm";
1556 case FILE_PNG: return "png";
1557 case FILE_PNG_LIST: return "png";
1558 case FILE_TGA: return "tga";
1559 case FILE_TGA_LIST: return "tga";
1560 case FILE_TIFF: return "tif";
1561 case FILE_TIFF_LIST: return "tif";
1562 case FILE_VMPEG: return "m2v";
1563 case FILE_VORBIS: return "ogg";
1564 case FILE_WAV: return "wav";
1565 case FILE_FFMPEG: return "ffmpg";
1570 const char* File::get_prefix(int format)
1573 case FILE_PCM: return "PCM";
1574 case FILE_WAV: return "WAV";
1575 case FILE_PNG: return "PNG";
1576 case FILE_JPEG: return "JPEG";
1577 case FILE_TIFF: return "TIFF";
1578 case FILE_GIF: return "GIF";
1579 case FILE_JPEG_LIST: return "JPEG_LIST";
1580 case FILE_AU: return "AU";
1581 case FILE_AIFF: return "AIFF";
1582 case FILE_SND: return "SND";
1583 case FILE_TGA_LIST: return "TGA_LIST";
1584 case FILE_TGA: return "TGA";
1585 case FILE_MPEG: return "MPEG";
1586 case FILE_AMPEG: return "AMPEG";
1587 case FILE_VMPEG: return "VMPEG";
1588 case FILE_RAWDV: return "RAWDV";
1589 case FILE_TIFF_LIST: return "TIFF_LIST";
1590 case FILE_PNG_LIST: return "PNG_LIST";
1591 case FILE_AC3: return "AC3";
1592 case FILE_EXR: return "EXR";
1593 case FILE_EXR_LIST: return "EXR_LIST";
1594 case FILE_CR2: return "CR2";
1595 case FILE_OGG: return "OGG";
1596 case FILE_VORBIS: return "VORBIS";
1597 case FILE_FLAC: return "FLAC";
1598 case FILE_FFMPEG: return "FFMPEG";
1599 case FILE_SCENE: return "SCENE";
1600 case FILE_CR2_LIST: return "CR2_LIST";
1601 case FILE_GIF_LIST: return "GIF_LIST";
1602 case FILE_DB: return "DB";
1604 return _("UNKNOWN");
1608 PackagingEngine *File::new_packaging_engine(Asset *asset)
1610 PackagingEngine *result;
1611 switch (asset->format)
1614 result = (PackagingEngine*)new PackagingEngineOGG();
1617 result = (PackagingEngine*) new PackagingEngineDefault();
1625 int File::record_fd()
1627 return file ? file->record_fd() : -1;
1631 void get_exe_path(char *result)
1633 // Get executable path
1634 int len = readlink("/proc/self/exe", result, BCTEXTLEN-1);
1637 char *ptr = strrchr(result, '/');