ffmpeg versioning mods from Andrew
[goodguy/cinelerra.git] / cinelerra-5.1 / cinelerra / batchrender.h
1
2 /*
3  * CINELERRA
4  * Copyright (C) 2008 Adam Williams <broadcast at earthling dot net>
5  *
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.
10  *
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.
15  *
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
19  *
20  */
21
22 #ifndef BATCHRENDER_H
23 #define BATCHRENDER_H
24
25 #include "arraylist.h"
26 #include "asset.inc"
27 #include "batchrender.inc"
28 #include "bcbutton.h"
29 #include "bcdialog.h"
30 #include "browsebutton.inc"
31 #include "filexml.inc"
32 #include "formattools.h"
33 #include "indexable.inc"
34 #include "keyframe.inc"
35 #include "mwindow.inc"
36 #include "preferences.inc"
37 #include "render.inc"
38 #include "timeentry.h"
39
40 enum {
41         ENABLED_COL, LABELED_COL, FARMED_COL,
42         OUTPUT_COL, EDL_COL, ELAPSED_COL,
43         BATCHRENDER_COLUMNS
44 };
45
46 class BatchRenderMenuItem : public BC_MenuItem
47 {
48 public:
49         BatchRenderMenuItem(MWindow *mwindow);
50         int handle_event();
51         MWindow *mwindow;
52 };
53
54
55
56 class BatchRenderJob
57 {
58 public:
59         BatchRenderJob(const char *tag,
60                 Preferences *preferences, int labeled, int farmed);
61         BatchRenderJob(Preferences *preferences, int labeled, int farmed);
62         BatchRenderJob(const char *tag);
63         virtual ~BatchRenderJob();
64         virtual BatchRenderJob *copy();
65         virtual void load(FileXML *file);
66         virtual void save(FileXML *file);
67         virtual int get_strategy();
68         virtual char *create_script(EDL *edl, ArrayList<Indexable *> *idxbls);
69         void copy_from(BatchRenderJob *src);
70
71         const char *tag;
72 // Source EDL to render
73         char edl_path[BCTEXTLEN];
74 // Destination file for output
75         Asset *asset;
76         int labeled, farmed;
77         int enabled;
78 // Amount of time elapsed in last render operation
79         double elapsed;
80         Preferences *preferences;
81 };
82
83
84 class BatchRenderWarnJob
85 {
86 public:
87         BatchRenderWarnJob() { no = 0; path = 0; }
88         ~BatchRenderWarnJob() { delete [] path; }
89         int no;
90         const char *path;
91 };
92
93 class BatchRenderWarnJobs : public ArrayList<BatchRenderWarnJob>
94 {
95 public:
96         BatchRenderWarnJobs() {}
97         ~BatchRenderWarnJobs() {}
98         void add(int no, const char *path) {
99                 BatchRenderWarnJob &job = append();
100                 job.no = no;  job.path = cstrdup(path);
101         }
102 };
103
104 class BatchRenderThread : public BC_DialogThread
105 {
106 public:
107         BatchRenderThread(MWindow *mwindow=0);
108         ~BatchRenderThread();
109         void handle_close_event(int result);
110         BC_Window* new_gui();
111
112         int test_edl_files();
113         int test_errmsg(BatchRenderWarnJobs &err_jobs, const char *msg, int *warn);
114         void calculate_dest_paths(ArrayList<char*> *paths,
115                 Preferences *preferences);
116         void reset(const char *path=0);
117 // Load batch rendering jobs
118         void load_jobs(char *path, Preferences *preferences);
119 // Not applicable to western civilizations
120         void save_jobs(char *path=0);
121         void load_defaults(BC_Hash *defaults);
122         void save_defaults(BC_Hash *defaults);
123 // Create path for persistent storage functions
124         char* create_path(char *string);
125         void new_job();
126         void delete_job();
127         void update_selected_edl();
128         void use_current_edl();
129 // Conditionally returns the job or the default job based on current_job
130         BatchRenderJob* get_current_job();
131         Asset* get_current_asset();
132         char* get_current_edl();
133 // For command line usage
134         void start_rendering(char *config_path, char *batch_path);
135 // For GUI usage
136         void start_rendering();
137         void stop_rendering();
138 // Highlight the currently rendering job.
139         void update_active(int number);
140         void update_done(int number, int create_list, double elapsed_time);
141         void move_batch(int src, int dst);
142         void start(int do_farmed, int do_labeled);
143         static void trap_hook(FILE *fp, void *vp);
144
145         MWindow *mwindow;
146         char batch_path[BCTEXTLEN];
147         double current_start;
148         double current_end;
149         BatchRenderJob *default_job;
150         ArrayList<BatchRenderJob*> jobs;
151         BC_Hash *boot_defaults;
152         Preferences *preferences;
153         Render *render;
154         BatchRenderGUI *gui;
155
156         static const char *column_titles[BATCHRENDER_COLUMNS];
157         static int column_widths[BATCHRENDER_COLUMNS];
158         int list_width[BATCHRENDER_COLUMNS];
159         int do_farmed;
160         int do_labeled;
161 // job being edited
162         int current_job;
163 // job being rendered
164         int rendering_job;
165         int is_rendering;
166         int warn;
167 };
168
169
170
171 class BatchRenderEDLPath : public BC_TextBox
172 {
173 public:
174         BatchRenderEDLPath(BatchRenderThread *thread, int x, int y, int w,
175                 char *text);
176         int handle_event();
177         BatchRenderThread *thread;
178 };
179
180
181 class BatchRenderCurrentEDL : public BC_GenericButton
182 {
183 public:
184         BatchRenderCurrentEDL(BatchRenderThread *thread, int x, int y);
185         int handle_event();
186         BatchRenderThread *thread;
187 };
188
189
190 class BatchRenderUpdateEDL : public BC_GenericButton
191 {
192 public:
193         BatchRenderUpdateEDL(BatchRenderThread *thread, int x, int y);
194         int handle_event();
195         BatchRenderThread *thread;
196 };
197
198
199 class BatchRenderNew : public BC_GenericButton
200 {
201 public:
202         BatchRenderNew(BatchRenderThread *thread, int x, int y);
203         int handle_event();
204         BatchRenderThread *thread;
205 };
206
207 class BatchRenderDelete : public BC_GenericButton
208 {
209 public:
210         BatchRenderDelete(BatchRenderThread *thread, int x, int y);
211         int handle_event();
212         BatchRenderThread *thread;
213 };
214
215
216
217 class BatchRenderSaveList : public BC_GenericButton, public Thread
218 {
219 public:
220         BatchRenderSaveList(BatchRenderThread *thread, int x, int y);
221         ~BatchRenderSaveList();
222         int handle_event();
223         BatchRenderThread *thread;
224         BC_FileBox *gui;
225         void run();
226         void stop();
227         virtual int keypress_event();
228         Mutex *startup_lock;
229 };
230
231 class BatchRenderLoadList : public BC_GenericButton, public Thread
232 {
233 public:
234         BatchRenderLoadList(BatchRenderThread *thread, int x, int y);
235         ~BatchRenderLoadList();
236         int handle_event();
237         BatchRenderThread *thread;
238         BC_FileBox *gui;
239         void run();
240         void stop();
241         virtual int keypress_event();
242         Mutex *startup_lock;
243 };
244
245
246
247 class BatchRenderList : public BC_ListBox
248 {
249 public:
250         BatchRenderList(BatchRenderThread *thread, int x, int y, int w, int h);
251         int handle_event();
252         int selection_changed();
253         int column_resize_event();
254         int drag_start_event();
255         int drag_motion_event();
256         int drag_stop_event();
257         int dragging_item;
258         BatchRenderThread *thread;
259 };
260 class BatchRenderStart : public BC_GenericButton
261 {
262 public:
263         BatchRenderStart(BatchRenderThread *thread, int x, int y);
264         int handle_event();
265         BatchRenderThread *thread;
266 };
267
268 class BatchRenderStop : public BC_GenericButton
269 {
270 public:
271         BatchRenderStop(BatchRenderThread *thread, int x, int y);
272         int handle_event();
273         BatchRenderThread *thread;
274 };
275
276 class BatchRenderWarning : public BC_CheckBox
277 {
278 public:
279         BatchRenderWarning(BatchRenderThread *thread, int x, int y);
280         int handle_event();
281         BatchRenderThread *thread;
282 };
283
284 class BatchRenderCancel : public BC_GenericButton
285 {
286 public:
287         BatchRenderCancel(BatchRenderThread *thread, int x, int y);
288         int handle_event();
289         int keypress_event();
290         BatchRenderThread *thread;
291 };
292
293
294 class BatchFormat : public FormatTools
295 {
296 public:
297         BatchFormat(MWindow *mwindow, BatchRenderGUI *gui, Asset *asset);
298         ~BatchFormat();
299
300         int handle_event();
301
302         BatchRenderGUI *gui;
303         MWindow *mwindow;
304 };
305
306 class BatchRenderUseFarm : public BC_CheckBox
307 {
308 public:
309         BatchRenderUseFarm(BatchRenderThread *thread, int x, int y, int *output);
310         int handle_event();
311         void update(int *output);
312
313         BatchRenderThread *thread;
314         int *output;
315 };
316
317 //new help button
318 class BatchRenderHelp : public BC_GenericButton
319 {
320 public:
321         BatchRenderHelp(BatchRenderThread *thread, int x, int y);
322         int handle_event();
323         BatchRenderThread *thread;
324 };
325
326 class BatchRenderGUI : public BC_Window
327 {
328 public:
329         BatchRenderGUI(MWindow *mwindow,
330                 BatchRenderThread *thread,
331                 int x,
332                 int y,
333                 int w,
334                 int h);
335         ~BatchRenderGUI();
336
337         void create_objects();
338         int resize_event(int w, int h);
339         int translation_event();
340         int close_event();
341         void create_list(int update_widget);
342         void change_job();
343         void button_enable();
344         void button_disable();
345
346         ArrayList<BC_ListBoxItem*> list_items[BATCHRENDER_COLUMNS];
347         const char *list_titles[BATCHRENDER_COLUMNS];
348         int list_width[BATCHRENDER_COLUMNS], list_columns;
349
350         MWindow *mwindow;
351         BatchRenderThread *thread;
352         BC_Title *output_path_title;
353         BatchFormat *format_tools;
354         BrowseButton *edl_path_browse;
355         BatchRenderEDLPath *edl_path_text;
356         BC_Title *edl_path_title;
357 //      BC_Title *status_title;
358 //      BC_Title *status_text;
359 //      BC_ProgressBar *progress_bar;
360         BC_Title *list_title;
361         BC_Title *batch_path;
362         BatchRenderNew *new_batch;
363         BatchRenderDelete *delete_batch;
364         BatchRenderSaveList *savelist_batch;
365         BatchRenderLoadList *loadlist_batch;
366         BatchRenderWarning *warning;
367         BatchRenderList *batch_list;
368         BatchRenderStart *start_button;
369         BatchRenderStop *stop_button;
370         BatchRenderCancel *cancel_button;
371         BatchRenderCurrentEDL *use_current_edl;
372         BatchRenderUpdateEDL *update_selected_edl;
373         BatchRenderUseFarm *use_renderfarm;
374         BatchRenderHelp *help_button;
375 };
376
377
378 #endif