ffmpeg.h 15.2 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 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230
} 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;
231
    int reconfiguration;
232 233 234 235 236 237 238 239 240 241 242 243

    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 */
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
244
    AVCodecContext *dec_ctx;
245 246
    AVCodec *dec;
    AVFrame *decoded_frame;
247
    AVFrame *filter_frame; /* a ref of decoded_frame, to be sent to filters */
248 249 250

    int64_t       start;     /* time when read started */
    /* predicted dts of the next packet read for this stream or (when there are
251
     * several frames in a packet) of the next frame in current packet (in AV_TIME_BASE units) */
252
    int64_t       next_dts;
253 254 255 256 257
    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;
258 259 260

    int64_t filter_in_rescale_delta_last;

261
    double ts_scale;
262
    int saw_first_ts;
263
    int showed_multi_packet_warning;
264
    AVDictionary *decoder_opts;
265
    AVRational framerate;               /* framerate forced with -r */
266
    int top_field_first;
267
    int guess_layout_max;
268 269 270 271 272 273 274 275 276 277

    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;

278 279 280 281 282 283 284
    int fix_sub_duration;
    struct { /* previous decoded subtitle and related variables */
        int got_output;
        int ret;
        AVSubtitle subtitle;
    } prev_sub;

285 286
    struct sub2video {
        int64_t last_pts;
287
        int64_t end_pts;
288
        AVFrame *frame;
289 290 291 292
        int w, h;
    } sub2video;

    int dr1;
293 294 295 296 297

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

    int reinit_filters;
300

301 302 303 304 305 306 307 308 309 310 311 312
    /* 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;
313 314 315 316 317 318 319 320 321

    /* 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;
322 323 324 325 326
} InputStream;

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

#if HAVE_PTHREADS
341
    AVThreadMessageQueue *in_thread_queue;
342
    pthread_t thread;           /* thread reading from this file */
343
    int non_blocking;           /* reading packets from the thread should not block */
344 345 346 347
    int joined;                 /* the thread has been joined */
#endif
} InputFile;

348 349 350 351 352 353 354 355 356 357 358
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[];

359 360 361 362 363
typedef enum {
    ENCODER_FINISHED = 1,
    MUXER_FINISHED = 2,
} OSTFinished ;

364 365 366 367 368 369 370 371 372 373 374 375 376 377
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;
378 379
    /* dts of the last packet sent to the muxer */
    int64_t last_mux_dts;
380
    AVBitStreamFilterContext *bitstream_filters;
381
    AVCodecContext *enc_ctx;
382 383 384 385 386 387 388 389 390
    AVCodec *enc;
    int64_t max_frames;
    AVFrame *filtered_frame;

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

391
    AVRational frame_aspect_ratio;
392 393 394 395 396 397

    /* forced key frames */
    int64_t *forced_kf_pts;
    int forced_kf_count;
    int forced_kf_index;
    char *forced_keyframes;
398 399
    AVExpr *forced_keyframes_pexpr;
    double forced_keyframes_expr_const_values[FKF_NB];
400

401 402 403 404
    /* audio only */
    int audio_channels_map[SWR_CH_MAX];  /* list of the channels id to pick from the source stream */
    int audio_channels_mapped;           /* number of channels in audio_channels_map */

405
    char *logfile_prefix;
406 407 408 409
    FILE *logfile;

    OutputFilter *filter;
    char *avfilter;
410 411
    char *filters;         ///< filtergraph associated to the -filter option
    char *filters_script;  ///< filtergraph script associated to the -filter_script option
412 413

    int64_t sws_flags;
414
    AVDictionary *encoder_opts;
415
    AVDictionary *swr_opts;
416
    AVDictionary *resample_opts;
417
    char *apad;
418
    OSTFinished finished;        /* no more packets should be written for this stream */
419
    int unavailable;                     /* true if the steram is unavailable (possibly temporarily) */
420 421 422
    int stream_copy;
    const char *attachment_filename;
    int copy_initial_nonkeyframes;
423
    int copy_prior_start;
424

425
    int keep_pix_fmt;
426 427

    AVCodecParserContext *parser;
428 429 430 431

    /* stats */
    // combined size of all the packets written
    uint64_t data_size;
432 433 434 435 436
    // 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;
437 438 439 440 441 442
} OutputStream;

typedef struct OutputFile {
    AVFormatContext *ctx;
    AVDictionary *opts;
    int ost_index;       /* index of the first stream in output_streams */
443 444 445
    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 */
446 447

    int shortest;
448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466
} 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;

extern float audio_drift_threshold;
extern float dts_delta_threshold;
467
extern float dts_error_threshold;
468 469 470 471 472

extern int audio_volume;
extern int audio_sync_method;
extern int video_sync_method;
extern int do_benchmark;
473
extern int do_benchmark_all;
474 475 476 477 478
extern int do_deinterlace;
extern int do_hex_dump;
extern int do_pkt_dump;
extern int copy_ts;
extern int copy_tb;
479
extern int debug_ts;
480 481 482
extern int exit_on_error;
extern int print_stats;
extern int qp_hist;
483 484 485
extern int stdin_interaction;
extern int frame_bits_per_raw_sample;
extern AVIOContext *progress_avio;
486
extern float max_error_rate;
487 488 489 490

extern const AVIOInterruptCB int_cb;

extern const OptionDef options[];
491 492
extern const HWAccel hwaccels[];

493

494 495
void term_init(void);
void term_exit(void);
496

497 498
void reset_options(OptionsContext *o, int is_input);
void show_usage(void);
499 500 501 502 503 504 505

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

void assert_avoptions(AVDictionary *m);

int guess_input_channel_layout(InputStream *ist);

506
enum AVPixelFormat choose_pixel_fmt(AVStream *st, AVCodecContext *avctx, AVCodec *codec, enum AVPixelFormat target);
507 508
void choose_sample_fmt(AVStream *st, AVCodec *codec);

509 510
int configure_filtergraph(FilterGraph *fg);
int configure_output_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out);
511 512
int ist_in_filtergraph(FilterGraph *fg, InputStream *ist);
FilterGraph *init_simple_filtergraph(InputStream *ist, OutputStream *ost);
513

514
int ffmpeg_parse_options(int argc, char **argv);
515

516
int vdpau_init(AVCodecContext *s);
517
int dxva2_init(AVCodecContext *s);
518
int vda_init(AVCodecContext *s);
519

520
#endif /* FFMPEG_H */