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