additional TERMUX related mods from Andrew
[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 FFMPEGConfigWindow : public BC_Window
159 {
160 public:
161         FFMPEGConfigWindow(const char *title, BC_WindowBase *parent_window,
162                 int x, int y, int w, int h, Asset *asset, EDL *edl);
163         ~FFMPEGConfigWindow();
164         virtual void read_options() = 0;
165         virtual void save_options() = 0;
166         void start(AVCodecContext *avctx);
167         void start(AVFormatContext *fmt_ctx);
168
169         BC_WindowBase *parent_window;
170         FFOptionsDialog *ff_options_dialog;
171         Asset *asset;
172         EDL *edl;
173         AVCodecContext *avctx;
174         AVFormatContext *fmt_ctx;
175         char *format_name;
176         char *codec_name;
177 };
178
179 class FFMPEGConfigAudio : public FFMPEGConfigWindow
180 {
181 public:
182         FFMPEGConfigAudio(BC_WindowBase *parent_window,
183                 int x, int y, Asset *asset, EDL *edl);
184         ~FFMPEGConfigAudio();
185
186         void create_objects();
187         int close_event();
188         void load_options();
189         void read_options();
190         void save_options();
191
192         FFMpegSampleFormat *sample_format;
193         ArrayList<BC_ListBoxItem*> presets;
194         FFMPEGConfigAudioPopup *preset_popup;
195         FFMpegAudioBitrate *bitrate;
196         FFMpegAudioQuality *quality;
197         FFAudioOptions *audio_options;
198         BC_WindowBase *parent_window;
199         FFOptionsViewAudio *view_audio;
200         FFOptionsViewFormat *view_format;
201 };
202
203 class FFAudioOptions : public BC_ScrollTextBox
204 {
205 public:
206         FFAudioOptions(FFMPEGConfigAudio *audio_popup,
207                 int x, int y, int w, int rows, int size, char *text);
208
209         FFMPEGConfigAudio *audio_popup;
210 };
211
212
213 class FFMPEGConfigAudioPopup : public BC_PopupTextBox
214 {
215 public:
216         FFMPEGConfigAudioPopup(FFMPEGConfigAudio *popup, int x, int y);
217         int handle_event();
218         FFMPEGConfigAudio *popup;
219 };
220
221 class FFMPEGConfigVideo : public FFMPEGConfigWindow
222 {
223 public:
224         FFMPEGConfigVideo(BC_WindowBase *parent_window,
225                 int x, int y, Asset *asset, EDL *edl);
226         ~FFMPEGConfigVideo();
227         void read_options();
228         void save_options();
229
230         void create_objects();
231         int close_event();
232         void load_options();
233
234         FFMpegPixelFormat *pixel_format;
235         ArrayList<BC_ListBoxItem*> presets;
236         FFMPEGConfigVideoPopup *preset_popup;
237         BC_WindowBase *parent_window;
238         FFMpegVideoBitrate *bitrate;
239         FFMpegVideoQuality *quality;
240         FFVideoOptions *video_options;
241         FFOptionsViewVideo *view_video;
242         FFOptionsViewFormat *view_format;
243 };
244
245 class FFVideoOptions : public BC_ScrollTextBox
246 {
247 public:
248         FFVideoOptions(FFMPEGConfigVideo *video_popup,
249                 int x, int y, int w, int rows, int size, char *text);
250
251         FFMPEGConfigVideo *video_popup;
252 };
253
254 class FFMPEGConfigVideoPopup : public BC_PopupTextBox
255 {
256 public:
257         FFMPEGConfigVideoPopup(FFMPEGConfigVideo *popup, int x, int y);
258         int handle_event();
259         FFMPEGConfigVideo *popup;
260 };
261
262 class FFMPEGConfigFormat : public FFMPEGConfigWindow
263 {
264 public:
265         FFMPEGConfigFormat(FFOptionsFormatViewDialog *view_dialog,
266                 int x, int y, Asset *asset, EDL *edl);
267         ~FFMPEGConfigFormat();
268         void read_options();
269         void save_options();
270         void save_changes();
271
272         void create_objects();
273         int close_event();
274         void load_options();
275
276         FFOptionsFormatViewDialog *view_dialog;
277         FFFormatOptions *format_options;
278 };
279
280 class FFFormatOptions : public BC_ScrollTextBox
281 {
282 public: 
283         FFFormatOptions(FFMPEGConfigFormat *format_popup,
284                 int x, int y, int w, int rows, int size, char *text);
285
286         FFMPEGConfigFormat *format_popup;
287 };
288
289
290 class FFMPEGScanProgress : public Thread
291 {
292 public:
293         IndexFile *index_file;
294         MainProgressBar *progress_bar;
295         char progress_title[BCTEXTLEN];
296         int64_t length, *position;
297         int done, *canceled;
298
299         FFMPEGScanProgress(IndexFile *index_file, MainProgressBar *progress_bar,
300                 const char *title, int64_t length, int64_t *position, int *canceled);
301         ~FFMPEGScanProgress();
302         void run();
303 };
304
305
306 class FFOptions_OptName : public BC_ListBoxItem {
307 public:
308         FFOptions_Opt *opt;
309
310         FFOptions_OptName(FFOptions_Opt *opt, const char *nm);
311         ~FFOptions_OptName();
312
313 };
314
315 class FFOptions_OptValue : public BC_ListBoxItem {
316 public:
317         FFOptions_Opt *opt;
318
319         void update();
320         void update(const char *v);
321         FFOptions_OptValue(FFOptions_Opt *opt);
322 };
323
324 class FFOptions_Opt {
325 public:
326         FFOptions *options;
327         const AVOption *opt;
328         FFOptions_OptName *item_name;
329         FFOptions_OptValue *item_value;
330
331         char *get(char *vp, int sz=-1);
332         void set(const char *val);
333         int types(char *rp);
334         int scalar(double d, char *rp);
335         int ranges(char *rp);
336         int units(ArrayList<const char *> &opts);
337         const char *unit_name(int id);
338         int units(char *rp);
339         const char *tip();
340
341         FFOptions_Opt(FFOptions *options, const AVOption *opt, const char *nm);
342         ~FFOptions_Opt();
343 };
344
345 class FFOptions : public ArrayList<FFOptions_Opt *>
346 {
347 public:
348         FFOptions();
349         ~FFOptions();
350         FFOptionsWindow *win;
351         AVCodecContext *avctx;
352         const void *obj;
353
354         void initialize(FFOptionsWindow *win, int kind);
355         static int cmpr(const void *a, const void *b);
356         int update();
357         void dump(FILE *fp);
358 };
359
360 class FFOptions_OptPanel : public BC_ListBox {
361 public:
362         FFOptions_OptPanel(FFOptionsWindow *fwin, int x, int y, int w, int h);
363         ~FFOptions_OptPanel();
364         void create_objects();
365         int cursor_leave_event();
366
367         FFOptionsWindow *fwin;
368         ArrayList<BC_ListBoxItem*> items[2];
369         ArrayList<BC_ListBoxItem*> &opts;
370         ArrayList<BC_ListBoxItem*> &vals;
371         char tip_text[BCTEXTLEN];
372
373         int selection_changed();
374         int update();
375         void show_tip(const char *tip);
376 };
377
378 class FFOptionsKindItem : public BC_MenuItem
379 {
380 public:
381         FFOptionsKind *kind;
382         int idx;
383         int handle_event();
384         void show_label();
385
386         FFOptionsKindItem(FFOptionsKind *kind, const char *name, int idx);
387         ~FFOptionsKindItem();
388 };
389
390 class FFOptionsKind : public BC_PopupMenu
391 {
392         static const char *kinds[];
393 public:
394         FFOptionsWindow *fwin;
395         int kind;
396
397         void create_objects();
398         int handle_event();
399         void set(int k);
400
401         FFOptionsKind(FFOptionsWindow *fwin, int x, int y, int w);
402         ~FFOptionsKind();
403 };
404
405 class FFOptionsUnits : public BC_PopupMenu {
406 public:
407         FFOptionsWindow *fwin;
408
409         FFOptionsUnits(FFOptionsWindow *fwin, int x, int y, int w);
410         ~FFOptionsUnits();
411         int handle_event();
412 };
413
414 class FFOptionsText : public BC_TextBox {
415 public:
416         FFOptionsWindow *fwin;
417
418         FFOptionsText(FFOptionsWindow *fwin, int x, int y, int w);
419         ~FFOptionsText();
420         int handle_event();
421 };
422
423 class FFOptionsApply : public BC_GenericButton {
424 public:
425         FFOptionsWindow *fwin;
426
427         FFOptionsApply(FFOptionsWindow *fwin, int x, int y);
428         ~FFOptionsApply();
429         int handle_event();
430 };
431
432 class FFOptionsWindow : public BC_Window
433 {
434 public:
435         FFOptionsWindow(FFOptionsDialog *dialog, int x, int y);
436         ~FFOptionsWindow();
437
438         void create_objects();
439         void update(FFOptions_Opt *oip);
440         void draw();
441         int resize_event(int w, int h);
442
443         FFOptionsDialog *dialog;
444         FFOptions options;
445
446         FFOptions_OptPanel *panel;
447         int panel_x, panel_y, panel_w, panel_h;
448         BC_Title *type, *range, *kind_title;
449         FFOptions_Opt *selected;
450
451         FFOptionsKind *kind;
452         FFOptionsUnits *units;
453         FFOptionsText *text;
454         FFOptionsApply *apply;
455 };
456
457 class FFOptionsDialog : public BC_DialogThread
458 {
459 public:
460         FFOptionsDialog(FFMPEGConfigWindow *cfg_window);
461         ~FFOptionsDialog();
462         virtual void update_options(const char *options) = 0;
463
464         void load_options(const char *bp, int len);
465         void store_options(char *cp, int len);
466         void start();
467         BC_Window* new_gui();
468         void handle_done_event(int result);
469
470         FFMPEGConfigWindow *cfg_window;
471         FFOptionsWindow *options_window;
472         AVDictionary *ff_opts;
473         int wx, wy;
474 };
475
476 class FFOptionsAudioDialog : public FFOptionsDialog
477 {
478 public:
479         FFMPEGConfigAudio *aud_config;
480         void update_options(const char *options);
481
482         FFOptionsAudioDialog(FFMPEGConfigAudio *aud_config);
483         ~FFOptionsAudioDialog();
484 };
485
486 class FFOptionsVideoDialog : public FFOptionsDialog
487 {
488 public:
489         FFMPEGConfigVideo *vid_config;
490         void update_options(const char *options);
491
492         FFOptionsVideoDialog(FFMPEGConfigVideo *vid_config);
493         ~FFOptionsVideoDialog();
494 };
495
496 class FFOptionsFormatDialog : public FFOptionsDialog
497 {
498 public:
499         FFMPEGConfigFormat *fmt_config;
500         void update_options(const char *options);
501
502         FFOptionsFormatDialog(FFMPEGConfigFormat *fmt_config);
503         ~FFOptionsFormatDialog();
504 };
505
506 class FFOptionsViewAudio : public BC_GenericButton
507 {
508 public:
509         FFOptionsViewAudio(FFMPEGConfigAudio *aud_config, int x, int y, const char *text);
510         ~FFOptionsViewAudio();
511
512         int handle_event();
513         FFMPEGConfigAudio *aud_config;
514         AVCodecContext *avctx;
515 };
516
517 class FFOptionsViewVideo : public BC_GenericButton
518 {
519 public:
520         FFOptionsViewVideo(FFMPEGConfigVideo *vid_config, int x, int y, const char *text);
521         ~FFOptionsViewVideo();
522
523         int handle_event();
524         FFMPEGConfigVideo *vid_config;
525         AVCodecContext *avctx;
526 };
527
528 class FFOptionsViewFormat : public BC_GenericButton
529 {
530 public:
531         FFOptionsViewFormat(FFMPEGConfigWindow *cfg_window,
532                 EDL *edl, Asset *asset, int x, int y, const char *text);
533         ~FFOptionsViewFormat();
534
535         int handle_event();
536         FFMPEGConfigWindow *cfg_window;
537         EDL *edl;
538         Asset *asset;
539         FFOptionsFormatViewDialog *format_dialog;
540 };
541
542 class FFOptionsFormatView : public BC_GenericButton
543 {
544 public:
545         FFOptionsFormatView(FFMPEGConfigFormat *fmt_config, int x, int y, const char *text);
546         ~FFOptionsFormatView();
547         int handle_event();
548
549         FFMPEGConfigFormat *fmt_config;
550         AVFormatContext *fmt_ctx;
551 };
552
553 class FFOptionsFormatViewDialog : public BC_DialogThread
554 {
555 public:
556         FFOptionsFormatViewDialog(FFOptionsViewFormat *view_format, int wx, int wy);
557         ~FFOptionsFormatViewDialog();
558         BC_Window* new_gui();
559         void handle_done_event(int result);
560
561         FFOptionsViewFormat *view_format;
562         FFMPEGConfigFormat *cfg_window;
563         int wx, wy;
564 };
565
566 #endif