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