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