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