4 * Copyright (C) 2009 Adam Williams <broadcast at earthling dot net>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 #include "condition.inc"
30 #include "filebase.inc"
33 #include "filethread.inc"
34 #include "filexml.inc"
35 #include "formattools.inc"
36 #include "formatwindow.inc"
37 #include "formattools.h"
38 #include "framecache.inc"
40 #include "indexfile.inc"
41 #include "mainprogress.inc"
43 #include "packagingengine.inc"
44 #include "pluginserver.inc"
45 #include "preferences.inc"
46 #include "samples.inc"
48 #include "packagingengine.h"
50 // ======================================= include file types here
54 // generic file opened by user
62 // Get attributes for various file formats.
63 // The dither parameter is carried over from recording, where dither is done at the device.
64 int get_options(FormatTools *format,
69 // Close parameter window
72 // ===================================== start here
73 int set_processors(int cpus); // Set the number of cpus for certain codecs.
74 // Set the number of bytes to preload during reads for Quicktime.
75 int set_preload(int64_t size);
76 // Set the subtitle for libzmpeg3. -1 disables subtitles.
77 void set_subtitle(int value);
78 // Set whether to interpolate raw images
79 void set_interpolate_raw(int value);
80 // Set whether to white balance raw images. Always 0 if no interpolation.
81 void set_white_balance_raw(int value);
82 // When loading, the asset is deleted and a copy created in the EDL.
83 // void set_asset(Asset *asset);
85 // Enable or disable frame caching. Must be tied to file to know when
86 // to delete the file object. Otherwise we'd delete just the cached frames
87 // while the list of open files grew.
88 void set_cache_frames(int value);
89 // Delete frame cache. Return 0 if successful. Return 1 if
92 // Delete oldest frame from cache. Return 0 if successful. Return 1 if
96 // Format may be preset if the asset format is not 0.
97 int open_file(Preferences *preferences,
102 // Get index from the file if one exists. Returns 0 on success.
103 int get_index(IndexFile *index_file, MainProgressBar *progress_bar);
105 // start a thread for writing to avoid blocking during record
106 int start_audio_thread(int buffer_size, int ring_buffers);
107 int stop_audio_thread();
108 // The ring buffer must either be 1 or 2.
109 // The buffer_size for video needs to be > 1 on SMP systems to utilize
110 // multiple processors.
111 // For audio it's the number of samples per buffer.
112 // compressed - if 1 write_compressed_frame is called
113 // if 0 write_frames is called
114 int start_video_thread(int buffer_size,
118 int stop_video_thread();
120 int start_video_decode_thread();
122 // Return the thread.
123 // Used by functions that read only.
124 FileThread* get_video_thread();
126 // write any headers and close file
127 // ignore_thread is used by SigHandler to break out of the threads.
128 int close_file(int ignore_thread = 0);
129 void delete_temp_samples_buffer();
130 void delete_temp_frame_buffer();
132 // get length of file normalized to base samplerate
133 int64_t get_audio_length();
134 int64_t get_video_length();
136 // get current position
137 int64_t get_audio_position();
138 int64_t get_video_position();
142 // write samples for the current channel
143 // written to disk and file pointer updated after last channel is written
144 // return 1 if failed
145 // subsequent writes must be <= than first write's size because of buffers
146 int write_samples(Samples **buffer, int64_t len);
148 // Only called by filethread to write an array of an array of channels of frames.
149 int write_frames(VFrame ***frames, int len);
153 // For writing buffers in a background thread use these functions to get the buffer.
154 // Get a pointer to a buffer to write to.
155 Samples** get_audio_buffer();
156 VFrame*** get_video_buffer();
158 // Used by ResourcePixmap to directly access the cache.
159 FrameCache* get_frame_cache();
161 // Schedule a buffer for writing on the thread.
162 // thread calls write_samples
163 int write_audio_buffer(int64_t len);
164 int write_video_buffer(int64_t len);
169 // set channel for buffer accesses
170 int set_channel(int channel);
173 // set dvd program, no=-1 get current program
174 int set_program(int no);
176 int get_cell_time(int no, double &time);
178 int get_video_pid(int track);
180 int get_video_info(int track, int &pid, double &framerate,
181 int &width, int &height, char *title);
182 // update asset with selected audio/video layer data
183 int select_video_stream(Asset *asset, int vstream);
184 int select_audio_stream(Asset *asset, int astream);
185 // get dvb system_time
186 int get_system_time(int64_t &tm);
187 // get dvb audio channels for video stream
188 int get_audio_for_video(int vstream, int astream, int64_t &channel_mask);
189 // get frame thumbnail data
190 int get_thumbnail(int stream,
191 int64_t &position, unsigned char *&thumbnail, int &ww, int &hh);
192 int set_skimming(int track, int skim, skim_fn fn, void *vp);
193 int skim_video(int track, void *vp, skim_fn fn);
195 // set position in samples
196 int set_audio_position(int64_t position);
198 // Read samples for one channel into a shared memory segment.
199 // The offset is the offset in floats from the beginning of the buffer and the len
200 // is the length in floats from the offset.
201 // advances file pointer
202 // return 1 if failed
203 int read_samples(Samples *buffer, int64_t len);
205 // set layer for video read
206 // is_thread is used by FileThread::run to prevent recursive lockup.
207 int set_layer(int layer, int is_thread = 0);
208 // set position in frames
209 // is_thread is set by FileThread::run to prevent recursive lockup.
210 // int set_video_position(int64_t position, float base_framerate /* = -1 */, int is_thread /* = 0 */);
211 int set_video_position(int64_t position, int is_thread /* = 0 */);
213 // Read frame of video into the argument
214 // is_thread is used by FileThread::run to prevent recursive lockup.
215 int read_frame(VFrame *frame, int is_thread = 0);
218 // The following involve no extra copies.
219 // Direct copy routines for direct copy playback
220 int can_copy_from(Asset *asset, int64_t position, int output_w, int output_h); // This file can copy frames directly from the asset
221 int get_render_strategy(ArrayList<int>* render_strategies);
222 int64_t compressed_frame_size();
223 int read_compressed_frame(VFrame *buffer);
224 int write_compressed_frame(VFrame *buffer);
226 // These are separated into two routines so a file doesn't have to be
228 // Get best colormodel to translate for hardware accelerated playback.
229 // Called by VRender.
230 int get_best_colormodel(int driver);
231 // Get best colormodel for hardware accelerated recording.
232 // Called by VideoDevice.
233 static int get_best_colormodel(Asset *asset, int driver);
234 // Get nearest colormodel that can be decoded without a temporary frame.
235 // Used by read_frame.
236 int colormodel_supported(int colormodel);
239 static const char *compressiontostr(const char *codec) { return codec; }
240 static const char *strtocompression(const char *string) { return string; }
241 // subclass memory usage
242 int64_t file_memory_usage();
243 // Used by CICache to calculate the total size of the cache.
244 // Based on temporary frames and a call to the file subclass.
245 // The return value is limited 1MB each in case of audio file.
246 // The minimum setting for cache_size should be bigger than 1MB.
247 int64_t get_memory_usage();
249 static int renders_video(int format);
250 static int renders_video(Asset *asset);
251 static int renders_audio(int format);
252 static int renders_audio(Asset *asset);
253 // Get the extension for the filename
254 static const char* get_tag(int format);
255 static const char* get_prefix(int format);
256 static int strtoformat(const char *format);
257 static const char* formattostr(int format);
258 static int is_image_render(int format);
259 static int strtobits(const char *bits);
260 static const char* bitstostr(int bits);
261 static int str_to_byteorder(const char *string);
262 static const char* byteorder_to_str(int byte_order);
263 int bytes_per_sample(int bits); // Convert the bit descriptor into a byte count.
264 // get record stream file descriptor
267 Asset *asset; // Copy of asset since File outlives EDL
268 FileBase *file; // virtual class for file type
269 // Threads for writing data in the background.
270 FileThread *audio_thread, *video_thread;
272 // Temporary storage for color conversions
275 // Temporary storage for get_audio_buffer.
276 // [ring buffers][channels][Samples]
277 Samples ***temp_samples_buffer;
279 // Temporary storage for get_video_buffer.
280 // [Ring buffers][layers][temp_frame_size][VFrame]
281 VFrame ****temp_frame_buffer;
282 // Return value of get_video_buffer
283 VFrame ***current_frame_buffer;
284 // server copies of variables for threaded recording
285 int audio_ring_buffers;
286 int video_ring_buffers;
287 // Number of frames in the temp_frame_buffer
288 int video_buffer_size;
290 // Lock writes while recording video and audio.
291 // A binary lock won't do. We need a FIFO lock.
292 Condition *write_lock;
294 int64_t playback_preload;
295 int playback_subtitle;
297 int white_balance_raw;
299 // Position information is migrated here to allow samplerate conversion.
300 // Current position in file's samplerate.
301 // Can't normalize to base samplerate because this would
302 // require fractional positioning to know if the file's position changed.
303 int64_t current_sample;
304 int64_t current_frame;
309 // Position information normalized to project rates
310 int64_t normalized_sample;
311 // int64_t normalized_sample_rate;
312 Preferences *preferences;
314 static PackagingEngine *new_packaging_engine(Asset *asset);
316 static void init_cin_path();
317 static void get_exe_path(char *result, char *bnp=0);
318 static void getenv_path(char *result, const char *path);
319 static void setenv_path(char *result, const char *var, const char *path);
320 static char cinexe_path[BCTEXTLEN], cinpkg_path[BCTEXTLEN];
321 static char cindat_path[BCTEXTLEN], cinlib_path[BCTEXTLEN];
322 static char cincfg_path[BCTEXTLEN], cinplg_path[BCTEXTLEN];
323 static char cinlad_path[BCTEXTLEN], cinlcl_path[BCTEXTLEN];
324 static char cinbwr_path[BCTEXTLEN];
325 static const char *get_cin() { return getenv("CIN_PKG"); }
326 static const char *get_cin_path() { return getenv("CIN_PATH"); }
327 static const char *get_cindat_path() { return getenv("CIN_DAT"); }
328 static const char *get_cinlib_path() { return getenv("CIN_LIB"); }
329 static const char *get_config_path() { return getenv("CIN_CONFIG"); }
330 static const char *get_plugin_path() { return getenv("CIN_PLUGIN"); }
331 static const char *get_ladspa_path() { return getenv("CIN_LADSPA"); }
332 static const char *get_locale_path() { return getenv("CIN_LOCALE"); }
333 static const char *get_browser_path() { return getenv("CIN_BROWSER"); }
335 static const char *default_probes[];
336 static const int nb_probes;
339 void reset_parameters();
342 BC_WindowBase *format_window;
343 Condition *format_completion;
344 FrameCache *frame_cache;
345 // Copy read frames to the cache