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