ffmpeg.h 15.6 KB
Newer Older
1
/*
2
 * This file is part of FFmpeg.
3
 *
4
 * FFmpeg is free software; you can redistribute it and/or
5 6 7 8
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
9
 * FFmpeg is distributed in the hope that it will be useful,
10 11 12 13 14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
15
 * License along with FFmpeg; if not, write to the Free Software
16 17 18
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

19 20
#ifndef FFMPEG_H
#define FFMPEG_H
21 22 23 24 25

#include "config.h"

#include <stdint.h>
#include <stdio.h>
26
#include <signal.h>
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

#if HAVE_PTHREADS
#include <pthread.h>
#endif

#include "cmdutils.h"

#include "libavformat/avformat.h"
#include "libavformat/avio.h"

#include "libavcodec/avcodec.h"

#include "libavfilter/avfilter.h"

#include "libavutil/avutil.h"
#include "libavutil/dict.h"
43
#include "libavutil/eval.h"
44 45 46
#include "libavutil/fifo.h"
#include "libavutil/pixfmt.h"
#include "libavutil/rational.h"
47
#include "libavutil/threadmessage.h"
48

49 50
#include "libswresample/swresample.h"

51 52 53 54
#define VSYNC_AUTO       -1
#define VSYNC_PASSTHROUGH 0
#define VSYNC_CFR         1
#define VSYNC_VFR         2
55
#define VSYNC_VSCFR       0xfe
56 57 58
#define VSYNC_DROP        0xff

#define MAX_STREAMS 1024    /* arbitrary sanity check value */
59

60 61 62
enum HWAccelID {
    HWACCEL_NONE = 0,
    HWACCEL_AUTO,
63
    HWACCEL_VDPAU,
64
    HWACCEL_DXVA2,
65
    HWACCEL_VDA,
66 67 68 69 70 71 72 73 74
};

typedef struct HWAccel {
    const char *name;
    int (*init)(AVCodecContext *s);
    enum HWAccelID id;
    enum AVPixelFormat pix_fmt;
} HWAccel;

75 76
/* select an input stream for an output stream */
typedef struct StreamMap {
77
    int disabled;           /* 1 is this mapping is disabled by a negative map */
78 79 80 81
    int file_index;
    int stream_index;
    int sync_file_index;
    int sync_stream_index;
82
    char *linklabel;       /* name of an output link, for mapping lavfi outputs */
83 84
} StreamMap;

85 86 87 88
typedef struct {
    int  file_idx,  stream_idx,  channel_idx; // input
    int ofile_idx, ostream_idx;               // output
} AudioChannelMap;
89 90

typedef struct OptionsContext {
91 92
    OptionGroup *g;

93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112
    /* input/output options */
    int64_t start_time;
    const char *format;

    SpecifierOpt *codec_names;
    int        nb_codec_names;
    SpecifierOpt *audio_channels;
    int        nb_audio_channels;
    SpecifierOpt *audio_sample_rate;
    int        nb_audio_sample_rate;
    SpecifierOpt *frame_rates;
    int        nb_frame_rates;
    SpecifierOpt *frame_sizes;
    int        nb_frame_sizes;
    SpecifierOpt *frame_pix_fmts;
    int        nb_frame_pix_fmts;

    /* input options */
    int64_t input_ts_offset;
    int rate_emu;
113
    int accurate_seek;
114 115 116 117 118

    SpecifierOpt *ts_scale;
    int        nb_ts_scale;
    SpecifierOpt *dump_attachment;
    int        nb_dump_attachment;
119 120 121 122
    SpecifierOpt *hwaccels;
    int        nb_hwaccels;
    SpecifierOpt *hwaccel_devices;
    int        nb_hwaccel_devices;
123 124 125 126

    /* output options */
    StreamMap *stream_maps;
    int     nb_stream_maps;
127 128
    AudioChannelMap *audio_channel_maps; /* one info entry per -map_channel */
    int           nb_audio_channel_maps; /* number of (valid) -map_channel settings */
129 130 131 132 133 134 135 136 137
    int metadata_global_manual;
    int metadata_streams_manual;
    int metadata_chapters_manual;
    const char **attachments;
    int       nb_attachments;

    int chapters_input_file;

    int64_t recording_time;
138
    int64_t stop_time;
139 140 141
    uint64_t limit_filesize;
    float mux_preload;
    float mux_max_delay;
142
    int shortest;
143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176

    int video_disable;
    int audio_disable;
    int subtitle_disable;
    int data_disable;

    /* indexed by output file stream index */
    int   *streamid_map;
    int nb_streamid_map;

    SpecifierOpt *metadata;
    int        nb_metadata;
    SpecifierOpt *max_frames;
    int        nb_max_frames;
    SpecifierOpt *bitstream_filters;
    int        nb_bitstream_filters;
    SpecifierOpt *codec_tags;
    int        nb_codec_tags;
    SpecifierOpt *sample_fmts;
    int        nb_sample_fmts;
    SpecifierOpt *qscale;
    int        nb_qscale;
    SpecifierOpt *forced_key_frames;
    int        nb_forced_key_frames;
    SpecifierOpt *force_fps;
    int        nb_force_fps;
    SpecifierOpt *frame_aspect_ratios;
    int        nb_frame_aspect_ratios;
    SpecifierOpt *rc_overrides;
    int        nb_rc_overrides;
    SpecifierOpt *intra_matrices;
    int        nb_intra_matrices;
    SpecifierOpt *inter_matrices;
    int        nb_inter_matrices;
177 178
    SpecifierOpt *chroma_intra_matrices;
    int        nb_chroma_intra_matrices;
179 180 181 182 183 184 185 186
    SpecifierOpt *top_field_first;
    int        nb_top_field_first;
    SpecifierOpt *metadata_map;
    int        nb_metadata_map;
    SpecifierOpt *presets;
    int        nb_presets;
    SpecifierOpt *copy_initial_nonkeyframes;
    int        nb_copy_initial_nonkeyframes;
187 188
    SpecifierOpt *copy_prior_start;
    int        nb_copy_prior_start;
189 190
    SpecifierOpt *filters;
    int        nb_filters;
191 192
    SpecifierOpt *filter_scripts;
    int        nb_filter_scripts;
193 194
    SpecifierOpt *reinit_filters;
    int        nb_reinit_filters;
195 196
    SpecifierOpt *fix_sub_duration;
    int        nb_fix_sub_duration;
197 198
    SpecifierOpt *canvas_sizes;
    int        nb_canvas_sizes;
199 200
    SpecifierOpt *pass;
    int        nb_pass;
201 202
    SpecifierOpt *passlogfiles;
    int        nb_passlogfiles;
203 204
    SpecifierOpt *guess_layout_max;
    int        nb_guess_layout_max;
205 206
    SpecifierOpt *apad;
    int        nb_apad;
207 208
    SpecifierOpt *discard;
    int        nb_discard;
209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232
} OptionsContext;

typedef struct InputFilter {
    AVFilterContext    *filter;
    struct InputStream *ist;
    struct FilterGraph *graph;
    uint8_t            *name;
} InputFilter;

typedef struct OutputFilter {
    AVFilterContext     *filter;
    struct OutputStream *ost;
    struct FilterGraph  *graph;
    uint8_t             *name;

    /* temporary storage until stream maps are processed */
    AVFilterInOut       *out_tmp;
} OutputFilter;

typedef struct FilterGraph {
    int            index;
    const char    *graph_desc;

    AVFilterGraph *graph;
233
    int reconfiguration;
234 235 236 237 238 239 240 241 242 243 244

    InputFilter   **inputs;
    int          nb_inputs;
    OutputFilter **outputs;
    int         nb_outputs;
} FilterGraph;

typedef struct InputStream {
    int file_index;
    AVStream *st;
    int discard;             /* true if stream data should be discarded */
245
    int user_set_discard;
246 247 248 249
    int decoding_needed;     /* non zero if the packets must be decoded in 'raw_fifo', see DECODING_FOR_* */
#define DECODING_FOR_OST    1
#define DECODING_FOR_FILTER 2

250
    AVCodecContext *dec_ctx;
251 252
    AVCodec *dec;
    AVFrame *decoded_frame;
253
    AVFrame *filter_frame; /* a ref of decoded_frame, to be sent to filters */
254 255 256

    int64_t       start;     /* time when read started */
    /* predicted dts of the next packet read for this stream or (when there are
257
     * several frames in a packet) of the next frame in current packet (in AV_TIME_BASE units) */
258
    int64_t       next_dts;
259 260 261 262 263
    int64_t       dts;       ///< dts of the last packet read for this stream (in AV_TIME_BASE units)

    int64_t       next_pts;  ///< synthetic pts for the next decode frame (in AV_TIME_BASE units)
    int64_t       pts;       ///< current pts of the decoded frame  (in AV_TIME_BASE units)
    int           wrap_correction_done;
264 265 266

    int64_t filter_in_rescale_delta_last;

267
    double ts_scale;
268
    int saw_first_ts;
269
    int showed_multi_packet_warning;
270
    AVDictionary *decoder_opts;
271
    AVRational framerate;               /* framerate forced with -r */
272
    int top_field_first;
273
    int guess_layout_max;
274 275 276 277 278 279 280 281 282 283

    int resample_height;
    int resample_width;
    int resample_pix_fmt;

    int      resample_sample_fmt;
    int      resample_sample_rate;
    int      resample_channels;
    uint64_t resample_channel_layout;

284 285 286 287 288 289 290
    int fix_sub_duration;
    struct { /* previous decoded subtitle and related variables */
        int got_output;
        int ret;
        AVSubtitle subtitle;
    } prev_sub;

291 292
    struct sub2video {
        int64_t last_pts;
293
        int64_t end_pts;
294
        AVFrame *frame;
295 296 297 298
        int w, h;
    } sub2video;

    int dr1;
299 300 301 302 303

    /* decoded data from this stream goes into all those filters
     * currently video and audio only */
    InputFilter **filters;
    int        nb_filters;
304 305

    int reinit_filters;
306

307 308 309 310 311 312 313 314 315 316 317 318
    /* hwaccel options */
    enum HWAccelID hwaccel_id;
    char  *hwaccel_device;

    /* hwaccel context */
    enum HWAccelID active_hwaccel_id;
    void  *hwaccel_ctx;
    void (*hwaccel_uninit)(AVCodecContext *s);
    int  (*hwaccel_get_buffer)(AVCodecContext *s, AVFrame *frame, int flags);
    int  (*hwaccel_retrieve_data)(AVCodecContext *s, AVFrame *frame);
    enum AVPixelFormat hwaccel_pix_fmt;
    enum AVPixelFormat hwaccel_retrieved_pix_fmt;
319 320 321 322 323 324 325 326 327

    /* stats */
    // combined size of all the packets read
    uint64_t data_size;
    /* number of packets successfully read for this stream */
    uint64_t nb_packets;
    // number of frames/samples retrieved from the decoder
    uint64_t frames_decoded;
    uint64_t samples_decoded;
328 329 330 331 332
} InputStream;

typedef struct InputFile {
    AVFormatContext *ctx;
    int eof_reached;      /* true if eof reached */
333
    int eagain;           /* true if last read attempt returned EAGAIN */
334
    int ist_index;        /* index of first stream in input_streams */
335
    int64_t input_ts_offset;
336
    int64_t ts_offset;
337
    int64_t last_ts;
338
    int64_t start_time;   /* user-specified start time in AV_TIME_BASE or AV_NOPTS_VALUE */
339
    int64_t recording_time;
340
    int nb_streams;       /* number of stream that ffmpeg is aware of; may be different
341
                             from ctx.nb_streams if new streams appear during av_read_frame() */
342
    int nb_streams_warn;  /* number of streams that the user was warned of */
343
    int rate_emu;
344
    int accurate_seek;
345 346

#if HAVE_PTHREADS
347
    AVThreadMessageQueue *in_thread_queue;
348
    pthread_t thread;           /* thread reading from this file */
349
    int non_blocking;           /* reading packets from the thread should not block */
350 351 352 353
    int joined;                 /* the thread has been joined */
#endif
} InputFile;

354 355 356 357 358 359 360 361 362 363 364
enum forced_keyframes_const {
    FKF_N,
    FKF_N_FORCED,
    FKF_PREV_FORCED_N,
    FKF_PREV_FORCED_T,
    FKF_T,
    FKF_NB
};

extern const char *const forced_keyframes_const_names[];

365 366 367 368 369
typedef enum {
    ENCODER_FINISHED = 1,
    MUXER_FINISHED = 2,
} OSTFinished ;

370 371 372 373 374 375 376 377 378 379 380 381 382 383
typedef struct OutputStream {
    int file_index;          /* file index */
    int index;               /* stream index in the output file */
    int source_index;        /* InputStream index */
    AVStream *st;            /* stream in the output file */
    int encoding_needed;     /* true if encoding needed for this stream */
    int frame_number;
    /* input pts and corresponding output pts
       for A/V sync */
    struct InputStream *sync_ist; /* input stream to sync against */
    int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ // FIXME look at frame_number
    /* pts of the first frame encoded for this stream, used for limiting
     * recording time */
    int64_t first_pts;
384 385
    /* dts of the last packet sent to the muxer */
    int64_t last_mux_dts;
386
    AVBitStreamFilterContext *bitstream_filters;
387
    AVCodecContext *enc_ctx;
388 389 390
    AVCodec *enc;
    int64_t max_frames;
    AVFrame *filtered_frame;
391 392
    AVFrame *last_frame;
    int last_droped;
393 394 395 396 397 398

    /* video only */
    AVRational frame_rate;
    int force_fps;
    int top_field_first;

399
    AVRational frame_aspect_ratio;
400 401 402 403 404 405

    /* forced key frames */
    int64_t *forced_kf_pts;
    int forced_kf_count;
    int forced_kf_index;
    char *forced_keyframes;
406 407
    AVExpr *forced_keyframes_pexpr;
    double forced_keyframes_expr_const_values[FKF_NB];
408

409
    /* audio only */
410
    int *audio_channels_map;             /* list of the channels id to pick from the source stream */
411 412
    int audio_channels_mapped;           /* number of channels in audio_channels_map */

413
    char *logfile_prefix;
414 415 416 417
    FILE *logfile;

    OutputFilter *filter;
    char *avfilter;
418 419
    char *filters;         ///< filtergraph associated to the -filter option
    char *filters_script;  ///< filtergraph script associated to the -filter_script option
420 421

    int64_t sws_flags;
422
    AVDictionary *encoder_opts;
423
    AVDictionary *swr_opts;
424
    AVDictionary *resample_opts;
425
    AVDictionary *bsf_args;
426
    char *apad;
427
    OSTFinished finished;        /* no more packets should be written for this stream */
428
    int unavailable;                     /* true if the steram is unavailable (possibly temporarily) */
429 430 431
    int stream_copy;
    const char *attachment_filename;
    int copy_initial_nonkeyframes;
432
    int copy_prior_start;
433

434
    int keep_pix_fmt;
435 436

    AVCodecParserContext *parser;
437 438 439 440

    /* stats */
    // combined size of all the packets written
    uint64_t data_size;
441 442 443 444 445
    // number of packets send to the muxer
    uint64_t packets_written;
    // number of frames/samples sent to the encoder
    uint64_t frames_encoded;
    uint64_t samples_encoded;
446 447 448 449 450 451
} OutputStream;

typedef struct OutputFile {
    AVFormatContext *ctx;
    AVDictionary *opts;
    int ost_index;       /* index of the first stream in output_streams */
452 453 454
    int64_t recording_time;  ///< desired length of the resulting file in microseconds == AV_TIME_BASE units
    int64_t start_time;      ///< start time in microseconds == AV_TIME_BASE units
    uint64_t limit_filesize; /* filesize limit expressed in bytes */
455 456

    int shortest;
457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472
} OutputFile;

extern InputStream **input_streams;
extern int        nb_input_streams;
extern InputFile   **input_files;
extern int        nb_input_files;

extern OutputStream **output_streams;
extern int         nb_output_streams;
extern OutputFile   **output_files;
extern int         nb_output_files;

extern FilterGraph **filtergraphs;
extern int        nb_filtergraphs;

extern char *vstats_filename;
473
extern char *sdp_filename;
474 475 476

extern float audio_drift_threshold;
extern float dts_delta_threshold;
477
extern float dts_error_threshold;
478 479 480 481 482

extern int audio_volume;
extern int audio_sync_method;
extern int video_sync_method;
extern int do_benchmark;
483
extern int do_benchmark_all;
484 485 486 487
extern int do_deinterlace;
extern int do_hex_dump;
extern int do_pkt_dump;
extern int copy_ts;
488
extern int start_at_zero;
489
extern int copy_tb;
490
extern int debug_ts;
491 492 493
extern int exit_on_error;
extern int print_stats;
extern int qp_hist;
494 495 496
extern int stdin_interaction;
extern int frame_bits_per_raw_sample;
extern AVIOContext *progress_avio;
497
extern float max_error_rate;
498
extern int vdpau_api_ver;
499 500 501 502

extern const AVIOInterruptCB int_cb;

extern const OptionDef options[];
503 504
extern const HWAccel hwaccels[];

505

506 507
void term_init(void);
void term_exit(void);
508

509 510
void reset_options(OptionsContext *o, int is_input);
void show_usage(void);
511 512 513

void opt_output_file(void *optctx, const char *filename);

514
void remove_avoptions(AVDictionary **a, AVDictionary *b);
515 516 517 518
void assert_avoptions(AVDictionary *m);

int guess_input_channel_layout(InputStream *ist);

519
enum AVPixelFormat choose_pixel_fmt(AVStream *st, AVCodecContext *avctx, AVCodec *codec, enum AVPixelFormat target);
520 521
void choose_sample_fmt(AVStream *st, AVCodec *codec);

522 523
int configure_filtergraph(FilterGraph *fg);
int configure_output_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out);
524 525
int ist_in_filtergraph(FilterGraph *fg, InputStream *ist);
FilterGraph *init_simple_filtergraph(InputStream *ist, OutputStream *ost);
526

527
int ffmpeg_parse_options(int argc, char **argv);
528

529
int vdpau_init(AVCodecContext *s);
530
int dxva2_init(AVCodecContext *s);
531
int vda_init(AVCodecContext *s);
532

533
#endif /* FFMPEG_H */