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