5453b77ca61d0f0c692484fd4c45b11d93747170
[goodguy/cinelerra.git] / cinelerra-5.1 / cinelerra / fileffmpeg.h
1 #ifndef __FILEFFMPEG_H__
2 #define __FILEFFMPEG_H__
3
4 #include "asset.inc"
5 #include "bcdialog.h"
6 #include "bcwindowbase.inc"
7 #include "bitspopup.inc"
8 #include "edl.inc"
9 #include "ffmpeg.h"
10 #include "filebase.h"
11 #include "fileffmpeg.inc"
12 #include "indexfile.inc"
13 #include "mainprogress.inc"
14 #include "mutex.h"
15 #include "thread.h"
16 #include "vframe.inc"
17
18 #include <stdio.h>
19 #include <stdint.h>
20 #include <stdlib.h>
21 #include <unistd.h>
22 #include <string.h>
23
24
25 class FileFFMPEG : public FileBase
26 {
27 public:
28         FFMPEG *ff;
29
30         FileFFMPEG(Asset *asset, File *file);
31         ~FileFFMPEG();
32         static void ff_lock(const char *cp=0);
33         static void ff_unlock();
34
35         static void set_options(char *cp, int len, const char *bp);
36         static void get_parameters(BC_WindowBase *parent_window,
37                 Asset *asset, BC_WindowBase *&format_window,
38                 int audio_options,int video_options, EDL *edl);
39         static int check_sig(Asset *asset);
40         int get_best_colormodel(int driver, int vstream);
41         int get_video_info(int track, int &pid, double &framerate,
42                 int &width, int &height, char *title=0);
43         int get_audio_for_video(int vstream, int astream, int64_t &channel_mask);
44         static void get_info(char *path,char *text,int len);
45         int open_file(int rd,int wr);
46         int get_index(IndexFile *index_file, MainProgressBar *progress_bar);
47         int close_file(void);
48         int write_samples(double **buffer,int64_t len);
49         int write_frames(VFrame ***frames,int len);
50         int read_samples(double *buffer,int64_t len);
51         int read_frame(VFrame *frame);
52         int can_scale_input() { return 1; }
53         int64_t get_memory_usage(void);
54         int colormodel_supported(int colormodel);
55         static int get_best_colormodel(Asset *asset, int driver);
56         int select_video_stream(Asset *asset, int vstream);
57         int select_audio_stream(Asset *asset, int astream);
58 };
59
60 class FFMpegConfigNum : public BC_TumbleTextBox
61 {
62 public:
63         FFMpegConfigNum(BC_Window *window, int x, int y,
64                 char *title_text, int *output);
65         ~FFMpegConfigNum();
66
67         void create_objects();
68         int update_param(const char *param, const char *opts);
69         int handle_event();
70         int *output;
71         BC_Window *window;
72         BC_Title *title;
73         char *title_text;
74         int x, y;
75 };
76
77 class FFMpegAudioNum : public FFMpegConfigNum
78 {
79 public:
80         FFMpegAudioNum(BC_Window *window, int x, int y, char *title_text, int *output);
81         ~FFMpegAudioNum() {}
82
83         FFMPEGConfigAudio *window() { return (FFMPEGConfigAudio *)FFMpegConfigNum::window; }
84 };
85
86 class FFMpegAudioBitrate : public FFMpegAudioNum
87 {
88 public:
89         FFMpegAudioBitrate(BC_Window *window, int x, int y, char *title_text, int *output)
90           : FFMpegAudioNum(window, x, y, title_text, output) {}
91         int handle_event();
92 };
93
94 class FFMpegAudioQuality : public FFMpegAudioNum
95 {
96 public:
97         FFMpegAudioQuality(BC_Window *window, int x, int y, char *title_text, int *output)
98           : FFMpegAudioNum(window, x, y, title_text, output) {}
99         int handle_event();
100 };
101
102 class FFMpegVideoNum : public FFMpegConfigNum
103 {
104 public:
105         FFMpegVideoNum(BC_Window *window, int x, int y, char *title_text, int *output);
106         ~FFMpegVideoNum() {}
107
108         FFMPEGConfigVideo *window() { return (FFMPEGConfigVideo *)FFMpegConfigNum::window; }
109 };
110
111 class FFMpegVideoBitrate : public FFMpegVideoNum
112 {
113 public:
114         FFMpegVideoBitrate(BC_Window *window, int x, int y, char *title_text, int *output)
115           : FFMpegVideoNum(window, x, y, title_text, output) {}
116         int handle_event();
117 };
118
119 class FFMpegVideoQuality : public FFMpegVideoNum
120 {
121 public:
122         FFMpegVideoQuality(BC_Window *window, int x, int y, char *title_text, int *output)
123           : FFMpegVideoNum(window, x, y, title_text, output) {}
124         int handle_event();
125 };
126
127 class FFMpegPixFmtItems : public ArrayList<BC_ListBoxItem*>
128 {
129 public:
130         FFMpegPixFmtItems() {}
131         ~FFMpegPixFmtItems() { remove_all_objects(); }
132 };
133
134 class FFMpegPixelFormat : public BC_PopupTextBox
135 {
136 public:
137         FFMpegPixelFormat(FFMPEGConfigVideo *vid_config, int x, int y, int w, int list_h);
138
139         FFMPEGConfigVideo *vid_config;
140         FFMpegPixFmtItems pixfmts;
141
142         int handle_event();
143         void update_formats();
144 };
145
146 class FFMpegSampleFormat : public BC_PopupTextBox
147 {
148 public:
149         FFMpegSampleFormat(FFMPEGConfigAudio *aud_config, int x, int y, int w, int list_h);
150
151         FFMPEGConfigAudio *aud_config;
152         ArrayList<BC_ListBoxItem*> samplefmts;
153
154         int handle_event();
155         void update_formats();
156 };
157
158 class FFMPEGConfigAudio : public BC_Window
159 {
160 public:
161         FFMPEGConfigAudio(BC_WindowBase *parent_window, Asset *asset, EDL *edl);
162         ~FFMPEGConfigAudio();
163
164         void create_objects();
165         int close_event();
166         void load_options();
167
168         FFMpegSampleFormat *sample_format;
169         ArrayList<BC_ListBoxItem*> presets;
170         FFMPEGConfigAudioPopup *preset_popup;
171         FFMpegAudioBitrate *bitrate;
172         FFMpegAudioQuality *quality;
173         FFAudioOptions *audio_options;
174         BC_WindowBase *parent_window;
175         Asset *asset;
176         EDL *edl;
177         FFOptionsDialog *ff_options_dialog;
178 };
179
180 class FFAudioOptions : public BC_ScrollTextBox
181 {
182 public:
183         FFAudioOptions(FFMPEGConfigAudio *audio_popup,
184                 int x, int y, int w, int rows, int size, char *text);
185
186         FFMPEGConfigAudio *audio_popup;
187 };
188
189
190 class FFMPEGConfigAudioPopup : public BC_PopupTextBox
191 {
192 public:
193         FFMPEGConfigAudioPopup(FFMPEGConfigAudio *popup, int x, int y);
194         int handle_event();
195         FFMPEGConfigAudio *popup;
196 };
197
198
199 class FFMPEGConfigAudioToggle : public BC_CheckBox
200 {
201 public:
202         FFMPEGConfigAudioToggle(FFMPEGConfigAudio *popup,
203                 char *title_text, int x, int y, int *output);
204         int handle_event();
205         int *output;
206         FFMPEGConfigAudio *popup;
207 };
208
209 class FFMPEGConfigVideo : public BC_Window
210 {
211 public:
212         FFMPEGConfigVideo(BC_WindowBase *parent_window, Asset *asset, EDL *edl);
213         ~FFMPEGConfigVideo();
214
215         void create_objects();
216         int close_event();
217         void load_options();
218
219         FFMpegPixelFormat *pixel_format;
220         ArrayList<BC_ListBoxItem*> presets;
221         FFMPEGConfigVideoPopup *preset_popup;
222         BC_WindowBase *parent_window;
223         FFMpegVideoBitrate *bitrate;
224         FFMpegVideoQuality *quality;
225         FFVideoOptions *video_options;
226         Asset *asset;
227         EDL *edl;
228         FFOptionsDialog *ff_options_dialog;
229 };
230
231 class FFVideoOptions : public BC_ScrollTextBox
232 {
233 public:
234         FFVideoOptions(FFMPEGConfigVideo *video_popup,
235                 int x, int y, int w, int rows, int size, char *text);
236
237         FFMPEGConfigVideo *video_popup;
238 };
239
240 class FFMPEGConfigVideoPopup : public BC_PopupTextBox
241 {
242 public:
243         FFMPEGConfigVideoPopup(FFMPEGConfigVideo *popup, int x, int y);
244         int handle_event();
245         FFMPEGConfigVideo *popup;
246 };
247
248 class FFMPEGConfigVideoToggle : public BC_CheckBox
249 {
250 public:
251         FFMPEGConfigVideoToggle(FFMPEGConfigVideo *popup,
252                 char *title_text, int x, int y, int *output);
253         int handle_event();
254         int *output;
255         FFMPEGConfigVideo *popup;
256 };
257
258 class FFMPEGScanProgress : public Thread
259 {
260 public:
261         IndexFile *index_file;
262         MainProgressBar *progress_bar;
263         char progress_title[BCTEXTLEN];
264         int64_t length, *position;
265         int done, *canceled;
266
267         FFMPEGScanProgress(IndexFile *index_file, MainProgressBar *progress_bar,
268                 const char *title, int64_t length, int64_t *position, int *canceled);
269         ~FFMPEGScanProgress();
270         void run();
271 };
272
273
274 class FFOptions_OptName : public BC_ListBoxItem {
275 public:
276         FFOptions_Opt *opt;
277
278         FFOptions_OptName(FFOptions_Opt *opt, const char *nm);
279         ~FFOptions_OptName();
280
281 };
282
283 class FFOptions_OptValue : public BC_ListBoxItem {
284 public:
285         FFOptions_Opt *opt;
286
287         void update();
288         void update(const char *v);
289         FFOptions_OptValue(FFOptions_Opt *opt);
290 };
291
292 class FFOptions_Opt {
293 public:
294         FFOptions *options;
295         const AVOption *opt;
296         FFOptions_OptName *item_name;
297         FFOptions_OptValue *item_value;
298
299         char *get(char *vp, int sz=-1);
300         void set(const char *val);
301         int types(char *rp);
302         int scalar(double d, char *rp);
303         int ranges(char *rp);
304         int units(ArrayList<const char *> &opts);
305         const char *unit_name(int id);
306         int units(char *rp);
307         const char *tip();
308
309         FFOptions_Opt(FFOptions *options, const AVOption *opt, const char *nm);
310         ~FFOptions_Opt();
311 };
312
313 class FFOptions : public ArrayList<FFOptions_Opt *>
314 {
315 public:
316         FFOptions();
317         ~FFOptions();
318         FFOptionsWindow *win;
319         AVCodecContext *avctx;
320         const void *obj;
321
322         void initialize(FFOptionsWindow *win, int k);
323         static int cmpr(const void *a, const void *b);
324         int update();
325         void dump(FILE *fp);
326 };
327
328 class FFOptions_OptPanel : public BC_ListBox {
329 public:
330         FFOptions_OptPanel(FFOptionsWindow *fwin, int x, int y, int w, int h);
331         ~FFOptions_OptPanel();
332         void create_objects();
333         int cursor_leave_event();
334
335         FFOptionsWindow *fwin;
336         ArrayList<BC_ListBoxItem*> items[2];
337         ArrayList<BC_ListBoxItem*> &opts;
338         ArrayList<BC_ListBoxItem*> &vals;
339         char tip_text[BCTEXTLEN];
340
341         int selection_changed();
342         int update();
343         void show_tip(const char *tip);
344 };
345
346 class FFOptionsKindItem : public BC_MenuItem
347 {
348 public:
349         FFOptionsKind *kind;
350         int idx;
351         int handle_event();
352         void show_label();
353
354         FFOptionsKindItem(FFOptionsKind *kind, const char *name, int idx);
355         ~FFOptionsKindItem();
356 };
357
358 class FFOptionsKind : public BC_PopupMenu
359 {
360         static const char *kinds[];
361 public:
362         FFOptionsWindow *fwin;
363         int kind;
364
365         void create_objects();
366         int handle_event();
367         void set(int k);
368
369         FFOptionsKind(FFOptionsWindow *fwin, int x, int y, int w);
370         ~FFOptionsKind();
371 };
372
373 class FFOptionsUnits : public BC_PopupMenu {
374 public:
375         FFOptionsWindow *fwin;
376
377         FFOptionsUnits(FFOptionsWindow *fwin, int x, int y, int w);
378         ~FFOptionsUnits();
379         int handle_event();
380 };
381
382 class FFOptionsText : public BC_TextBox {
383 public:
384         FFOptionsWindow *fwin;
385
386         FFOptionsText(FFOptionsWindow *fwin, int x, int y, int w);
387         ~FFOptionsText();
388         int handle_event();
389 };
390
391 class FFOptionsApply : public BC_GenericButton {
392 public:
393         FFOptionsWindow *fwin;
394
395         FFOptionsApply(FFOptionsWindow *fwin, int x, int y);
396         ~FFOptionsApply();
397         int handle_event();
398 };
399
400 class FFOptionsWindow : public BC_Window
401 {
402 public:
403         FFOptionsWindow(FFOptionsDialog *dialog);
404         ~FFOptionsWindow();
405
406         void create_objects();
407         void update(FFOptions_Opt *oip);
408         void draw();
409         int resize_event(int w, int h);
410
411         FFOptionsDialog *dialog;
412         FFOptions options;
413
414         FFOptions_OptPanel *panel;
415         int panel_x, panel_y, panel_w, panel_h;
416         BC_Title *type, *range, *kind_title;
417         FFOptions_Opt *selected;
418
419         FFOptionsKind *kind;
420         FFOptionsUnits *units;
421         FFOptionsText *text;
422         FFOptionsApply *apply;
423 };
424
425 class FFOptionsDialog : public BC_DialogThread
426 {
427 public:
428         FFOptionsDialog();
429         ~FFOptionsDialog();
430         virtual void update_options(const char *options) = 0;
431
432         void load_options(const char *bp, int len);
433         void store_options(char *cp, int len);
434         void start(const char *format_name, const char *codec_name,
435                 AVCodec *codec, const char *options, int len);
436         BC_Window* new_gui();
437         void handle_done_event(int result);
438
439         FFOptionsWindow *options_window;
440         const char *format_name, *codec_name;
441         AVCodec *codec;
442         AVDictionary *ff_opts;
443         int ff_len;
444 };
445
446 class FFOptionsAudioDialog : public FFOptionsDialog
447 {
448 public:
449         FFMPEGConfigAudio *aud_config;
450         void update_options(const char *options);
451
452         FFOptionsAudioDialog(FFMPEGConfigAudio *aud_config);
453         ~FFOptionsAudioDialog();
454 };
455
456 class FFOptionsVideoDialog : public FFOptionsDialog
457 {
458 public:
459         FFMPEGConfigVideo *vid_config;
460         void update_options(const char *options);
461
462         FFOptionsVideoDialog(FFMPEGConfigVideo *vid_config);
463         ~FFOptionsVideoDialog();
464 };
465
466 class FFOptionsViewAudio: public BC_GenericButton
467 {
468 public:
469         FFOptionsViewAudio(FFMPEGConfigAudio *aud_config, int x, int y, const char *text);
470         ~FFOptionsViewAudio();
471
472         int handle_event();
473         FFMPEGConfigAudio *aud_config;
474 };
475
476 class FFOptionsViewVideo : public BC_GenericButton
477 {
478 public:
479         FFOptionsViewVideo(FFMPEGConfigVideo *vid_config, int x, int y, const char *text);
480         ~FFOptionsViewVideo();
481
482         int handle_event();
483         FFMPEGConfigVideo *vid_config;
484 };
485
486 #endif