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