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