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