Skip to content
This repository

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

file 409 lines (341 sloc) 12.617 kb
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 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 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409
/*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* 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.
*
* FFmpeg is distributed in the hope that it will be useful,
* 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
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/

#ifndef FFMPEG_H
#define FFMPEG_H

#include "config.h"

#include <stdint.h>
#include <stdio.h>
#include <signal.h>

#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 "libavfilter/avfiltergraph.h"

#include "libavutil/avutil.h"
#include "libavutil/dict.h"
#include "libavutil/fifo.h"
#include "libavutil/pixfmt.h"
#include "libavutil/rational.h"

#include "libswresample/swresample.h"

#define VSYNC_AUTO -1
#define VSYNC_PASSTHROUGH 0
#define VSYNC_CFR 1
#define VSYNC_VFR 2
#define VSYNC_DROP 0xff

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

/* select an input stream for an output stream */
typedef struct StreamMap {
    int disabled; /** 1 is this mapping is disabled by a negative map */
    int file_index;
    int stream_index;
    int sync_file_index;
    int sync_stream_index;
    char *linklabel; /** name of an output link, for mapping lavfi outputs */
} StreamMap;

typedef struct {
    int file_idx, stream_idx, channel_idx; // input
    int ofile_idx, ostream_idx; // output
} AudioChannelMap;

typedef struct OptionsContext {
    /* 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;

    SpecifierOpt *ts_scale;
    int nb_ts_scale;
    SpecifierOpt *dump_attachment;
    int nb_dump_attachment;

    /* output options */
    StreamMap *stream_maps;
    int nb_stream_maps;
    AudioChannelMap *audio_channel_maps; /* one info entry per -map_channel */
    int nb_audio_channel_maps; /* number of (valid) -map_channel settings */
    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;
    uint64_t limit_filesize;
    float mux_preload;
    float mux_max_delay;
    int shortest;

    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;
    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;
    SpecifierOpt *copy_prior_start;
    int nb_copy_prior_start;
    SpecifierOpt *filters;
    int nb_filters;
    SpecifierOpt *fix_sub_duration;
    int nb_fix_sub_duration;
    SpecifierOpt *pass;
    int nb_pass;
    SpecifierOpt *passlogfiles;
    int nb_passlogfiles;
} 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;

    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;

    int64_t start; /* time when read started */
    /* predicted dts of the next packet read for this stream or (when there are
* several frames in a packet) of the next frame in current packet (in AV_TIME_BASE units) */
    int64_t next_dts;
    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;
    double ts_scale;
    int is_start; /* is 1 at the start and after a discontinuity */
    int saw_first_ts;
    int showed_multi_packet_warning;
    AVDictionary *opts;
    AVRational framerate; /* framerate forced with -r */
    int top_field_first;

    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;

    int fix_sub_duration;
    struct { /* previous decoded subtitle and related variables */
        int got_output;
        int ret;
        AVSubtitle subtitle;
    } prev_sub;

    struct sub2video {
        int64_t last_pts;
        AVFilterBufferRef *ref;
        int w, h;
    } sub2video;

    /* a pool of free buffers for decoded data */
    FrameBuffer *buffer_pool;
    int dr1;

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

typedef struct InputFile {
    AVFormatContext *ctx;
    int eof_reached; /* true if eof reached */
    int eagain; /* true if last read attempt returned EAGAIN */
    int ist_index; /* index of first stream in input_streams */
    int64_t ts_offset;
    int nb_streams; /* number of stream that ffmpeg is aware of; may be different
from ctx.nb_streams if new streams appear during av_read_frame() */
    int nb_streams_warn; /* number of streams that the user was warned of */
    int rate_emu;

#if HAVE_PTHREADS
    pthread_t thread; /* thread reading from this file */
    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;

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;
    AVBitStreamFilterContext *bitstream_filters;
    AVCodec *enc;
    int64_t max_frames;
    AVFrame *filtered_frame;

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

    float frame_aspect_ratio;
    float last_quality;

    /* forced key frames */
    int64_t *forced_kf_pts;
    int forced_kf_count;
    int forced_kf_index;
    char *forced_keyframes;

    /* 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 */

    char *logfile_prefix;
    FILE *logfile;

    OutputFilter *filter;
    char *avfilter;

    int64_t sws_flags;
    int64_t swr_dither_method;
    double swr_dither_scale;
    AVDictionary *opts;
    int finished; /* no more packets should be written for this stream */
    int unavailable; /* true if the steram is unavailable (possibly temporarily) */
    int stream_copy;
    const char *attachment_filename;
    int copy_initial_nonkeyframes;
    int copy_prior_start;

    int keep_pix_fmt;
} OutputStream;

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

    int shortest;
} 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;
extern float dts_error_threshold;

extern int audio_volume;
extern int audio_sync_method;
extern int video_sync_method;
extern int do_benchmark;
extern int do_benchmark_all;
extern int do_deinterlace;
extern int do_hex_dump;
extern int do_pkt_dump;
extern int copy_ts;
extern int copy_tb;
extern int debug_ts;
extern int exit_on_error;
extern int print_stats;
extern int qp_hist;
extern int same_quant;
extern int stdin_interaction;
extern int frame_bits_per_raw_sample;
extern AVIOContext *progress_avio;

extern const AVIOInterruptCB int_cb;

extern const OptionDef options[];

void term_init(void);
void term_exit(void);

void reset_options(OptionsContext *o, int is_input);
void show_usage(void);

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

void assert_avoptions(AVDictionary *m);

int guess_input_channel_layout(InputStream *ist);

enum PixelFormat choose_pixel_fmt(AVStream *st, AVCodec *codec, enum PixelFormat target);
void choose_sample_fmt(AVStream *st, AVCodec *codec);

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

#endif /* FFMPEG_H */
Something went wrong with that request. Please try again.