ffmpeg.h 15.3 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 47
#include "libavutil/fifo.h"
#include "libavutil/pixfmt.h"
#include "libavutil/rational.h"

48 49
#include "libswresample/swresample.h"

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

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

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

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

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

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

typedef struct OptionsContext {
90 91
    OptionGroup *g;

92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111
    /* 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;
112
    int accurate_seek;
113 114 115 116 117

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

    /* output options */
    StreamMap *stream_maps;
    int     nb_stream_maps;
126 127
    AudioChannelMap *audio_channel_maps; /* one info entry per -map_channel */
    int           nb_audio_channel_maps; /* number of (valid) -map_channel settings */
128 129 130 131 132 133 134 135 136
    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;
137
    int64_t stop_time;
138 139 140
    uint64_t limit_filesize;
    float mux_preload;
    float mux_max_delay;
141
    int shortest;
142 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

    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;
176 177
    SpecifierOpt *chroma_intra_matrices;
    int        nb_chroma_intra_matrices;
178 179 180 181 182 183 184 185
    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;
186 187
    SpecifierOpt *copy_prior_start;
    int        nb_copy_prior_start;
188 189
    SpecifierOpt *filters;
    int        nb_filters;
190 191
    SpecifierOpt *filter_scripts;
    int        nb_filter_scripts;
192 193
    SpecifierOpt *reinit_filters;
    int        nb_reinit_filters;
194 195
    SpecifierOpt *fix_sub_duration;
    int        nb_fix_sub_duration;
196 197
    SpecifierOpt *canvas_sizes;
    int        nb_canvas_sizes;
198 199
    SpecifierOpt *pass;
    int        nb_pass;
200 201
    SpecifierOpt *passlogfiles;
    int        nb_passlogfiles;
202 203
    SpecifierOpt *guess_layout_max;
    int        nb_guess_layout_max;
204 205
    SpecifierOpt *apad;
    int        nb_apad;
206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229
} 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;
230
    int reconfiguration;
231 232 233 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 */
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
    AVCodec *dec;
    AVFrame *decoded_frame;
245
    AVFrame *filter_frame; /* a ref of decoded_frame, to be sent to filters */
246 247 248

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

    int64_t filter_in_rescale_delta_last;

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

    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;

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

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

    int dr1;
291 292 293 294 295

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

    int reinit_filters;
298

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

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

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

#if HAVE_PTHREADS
    pthread_t thread;           /* thread reading from this file */
340
    int non_blocking;           /* reading packets from the thread should not block */
341 342 343 344 345 346 347 348
    int finished;               /* the thread has exited */
    int joined;                 /* the thread has been joined */
    pthread_mutex_t fifo_lock;  /* lock for access to fifo */
    pthread_cond_t  fifo_cond;  /* the main thread will signal on this cond after reading from fifo */
    AVFifoBuffer *fifo;         /* demuxed packets are stored here; freed by the main thread */
#endif
} InputFile;

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

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

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