mirror of
https://git.videolan.org/git/ffmpeg.git
synced 2024-09-11 01:47:55 +02:00
![Anton Khirnov](/assets/img/avatar_default.png)
Be more careful when an input stream encounters EOF when its filtergraph
has not been configured yet. The current code would immediately mark the
corresponding output streams as finished, while there may still be
buffered frames waiting for frames to appear on other filtergraph
inputs.
This should fix the random FATE failures for complex filtergraph tests
after a3a0230a98
505 lines
15 KiB
C
505 lines
15 KiB
C
/*
|
|
* This file is part of Libav.
|
|
*
|
|
* Libav 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.
|
|
*
|
|
* Libav 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 Libav; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
#ifndef AVCONV_H
|
|
#define AVCONV_H
|
|
|
|
#include "config.h"
|
|
|
|
#include <stdint.h>
|
|
#include <stdio.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 "libavutil/avutil.h"
|
|
#include "libavutil/dict.h"
|
|
#include "libavutil/fifo.h"
|
|
#include "libavutil/pixfmt.h"
|
|
#include "libavutil/rational.h"
|
|
|
|
#define VSYNC_AUTO -1
|
|
#define VSYNC_PASSTHROUGH 0
|
|
#define VSYNC_CFR 1
|
|
#define VSYNC_VFR 2
|
|
|
|
enum HWAccelID {
|
|
HWACCEL_NONE = 0,
|
|
HWACCEL_AUTO,
|
|
HWACCEL_VDPAU,
|
|
HWACCEL_DXVA2,
|
|
HWACCEL_VDA,
|
|
HWACCEL_QSV,
|
|
HWACCEL_VAAPI,
|
|
};
|
|
|
|
typedef struct HWAccel {
|
|
const char *name;
|
|
int (*init)(AVCodecContext *s);
|
|
enum HWAccelID id;
|
|
enum AVPixelFormat pix_fmt;
|
|
} HWAccel;
|
|
|
|
/* 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;
|
|
|
|
/* select an input file for an output file */
|
|
typedef struct MetadataMap {
|
|
int file; // file index
|
|
char type; // type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
|
|
int index; // stream/chapter/program number
|
|
} MetadataMap;
|
|
|
|
typedef struct OptionsContext {
|
|
OptionGroup *g;
|
|
|
|
/* 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 loop;
|
|
int rate_emu;
|
|
int accurate_seek;
|
|
|
|
SpecifierOpt *ts_scale;
|
|
int nb_ts_scale;
|
|
SpecifierOpt *dump_attachment;
|
|
int nb_dump_attachment;
|
|
SpecifierOpt *hwaccels;
|
|
int nb_hwaccels;
|
|
SpecifierOpt *hwaccel_devices;
|
|
int nb_hwaccel_devices;
|
|
SpecifierOpt *hwaccel_output_formats;
|
|
int nb_hwaccel_output_formats;
|
|
SpecifierOpt *autorotate;
|
|
int nb_autorotate;
|
|
|
|
/* output options */
|
|
StreamMap *stream_maps;
|
|
int nb_stream_maps;
|
|
/* first item specifies output metadata, second is input */
|
|
MetadataMap (*meta_data_maps)[2];
|
|
int nb_meta_data_maps;
|
|
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 *filters;
|
|
int nb_filters;
|
|
SpecifierOpt *filter_scripts;
|
|
int nb_filter_scripts;
|
|
SpecifierOpt *pass;
|
|
int nb_pass;
|
|
SpecifierOpt *passlogfiles;
|
|
int nb_passlogfiles;
|
|
SpecifierOpt *max_muxing_queue_size;
|
|
int nb_max_muxing_queue_size;
|
|
} OptionsContext;
|
|
|
|
typedef struct InputFilter {
|
|
AVFilterContext *filter;
|
|
struct InputStream *ist;
|
|
struct FilterGraph *graph;
|
|
uint8_t *name;
|
|
|
|
AVFifoBuffer *frame_queue;
|
|
|
|
// parameters configured for this input
|
|
int format;
|
|
|
|
int width, height;
|
|
AVRational sample_aspect_ratio;
|
|
|
|
int sample_rate;
|
|
uint64_t channel_layout;
|
|
|
|
AVBufferRef *hw_frames_ctx;
|
|
|
|
int eof;
|
|
} 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;
|
|
enum AVMediaType type;
|
|
|
|
/* desired output stream properties */
|
|
int width, height;
|
|
AVRational frame_rate;
|
|
int format;
|
|
int sample_rate;
|
|
uint64_t channel_layout;
|
|
|
|
// those are only set if no format is specified and the encoder gives us multiple options
|
|
int *formats;
|
|
uint64_t *channel_layouts;
|
|
int *sample_rates;
|
|
} 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' */
|
|
AVCodecContext *dec_ctx;
|
|
AVCodec *dec;
|
|
AVFrame *decoded_frame;
|
|
AVFrame *filter_frame; /* a ref of decoded_frame, to be sent to filters */
|
|
|
|
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 */
|
|
int64_t next_dts;
|
|
/* dts of the last packet read for this stream */
|
|
int64_t last_dts;
|
|
int64_t min_pts; /* pts with the smallest value in a current stream */
|
|
int64_t max_pts; /* pts with the higher value in a current stream */
|
|
int64_t nb_samples; /* number of samples in the last decoded audio frame before looping */
|
|
PtsCorrectionContext pts_ctx;
|
|
double ts_scale;
|
|
AVDictionary *decoder_opts;
|
|
AVRational framerate; /* framerate forced with -r */
|
|
|
|
int autorotate;
|
|
|
|
/* decoded data from this stream goes into all those filters
|
|
* currently video and audio only */
|
|
InputFilter **filters;
|
|
int nb_filters;
|
|
|
|
/* hwaccel options */
|
|
enum HWAccelID hwaccel_id;
|
|
char *hwaccel_device;
|
|
enum AVPixelFormat hwaccel_output_format;
|
|
|
|
/* 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;
|
|
AVBufferRef *hw_frames_ctx;
|
|
|
|
/* 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;
|
|
} 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 ist_table */
|
|
int loop; /* set number of times input stream should be looped */
|
|
int64_t duration; /* actual duration of the longest stream in a file
|
|
at the moment when looping happens */
|
|
AVRational time_base; /* time base of the duration */
|
|
int64_t ts_offset;
|
|
int64_t start_time; /* user-specified start time in AV_TIME_BASE or AV_NOPTS_VALUE */
|
|
int64_t recording_time;
|
|
int nb_streams; /* number of stream that avconv is aware of; may be different
|
|
from ctx.nb_streams if new streams appear during av_read_frame() */
|
|
int rate_emu;
|
|
int accurate_seek;
|
|
|
|
#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 */
|
|
// double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
|
|
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;
|
|
/* dts of the last packet sent to the muxer */
|
|
int64_t last_mux_dts;
|
|
// the timebase of the packets sent to the muxer
|
|
AVRational mux_timebase;
|
|
|
|
int nb_bitstream_filters;
|
|
const AVBitStreamFilter **bitstream_filters;
|
|
AVBSFContext **bsf_ctx;
|
|
|
|
AVCodecContext *enc_ctx;
|
|
AVCodec *enc;
|
|
int64_t max_frames;
|
|
AVFrame *filtered_frame;
|
|
|
|
void *hwaccel_ctx;
|
|
|
|
/* video only */
|
|
AVRational frame_rate;
|
|
int force_fps;
|
|
int top_field_first;
|
|
|
|
float frame_aspect_ratio;
|
|
|
|
/* forced key frames */
|
|
int64_t *forced_kf_pts;
|
|
int forced_kf_count;
|
|
int forced_kf_index;
|
|
char *forced_keyframes;
|
|
|
|
char *logfile_prefix;
|
|
FILE *logfile;
|
|
|
|
OutputFilter *filter;
|
|
char *avfilter;
|
|
|
|
int64_t sws_flags;
|
|
AVDictionary *encoder_opts;
|
|
AVDictionary *resample_opts;
|
|
int finished; /* no more packets should be written for this stream */
|
|
int stream_copy;
|
|
|
|
// init_output_stream() has been called for this stream
|
|
// The encoder and the bistream filters have been initialized and the stream
|
|
// parameters are set in the AVStream.
|
|
int initialized;
|
|
|
|
const char *attachment_filename;
|
|
int copy_initial_nonkeyframes;
|
|
|
|
enum AVPixelFormat pix_fmts[2];
|
|
|
|
AVCodecParserContext *parser;
|
|
AVCodecContext *parser_avctx;
|
|
|
|
/* stats */
|
|
// combined size of all the packets written
|
|
uint64_t data_size;
|
|
// 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;
|
|
|
|
/* packet quality factor */
|
|
int quality;
|
|
|
|
int max_muxing_queue_size;
|
|
|
|
/* the packets are buffered here until the muxer is ready to be initialized */
|
|
AVFifoBuffer *muxing_queue;
|
|
} 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 */
|
|
int64_t start_time; /* start time in microseconds */
|
|
uint64_t limit_filesize;
|
|
|
|
int shortest;
|
|
|
|
int header_written;
|
|
} 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 int audio_volume;
|
|
extern int audio_sync_method;
|
|
extern int video_sync_method;
|
|
extern int do_benchmark;
|
|
extern int do_deinterlace;
|
|
extern int do_hex_dump;
|
|
extern int do_pkt_dump;
|
|
extern int copy_ts;
|
|
extern int copy_tb;
|
|
extern int exit_on_error;
|
|
extern int print_stats;
|
|
extern int qp_hist;
|
|
|
|
extern const AVIOInterruptCB int_cb;
|
|
|
|
extern const OptionDef options[];
|
|
|
|
extern const HWAccel hwaccels[];
|
|
extern int hwaccel_lax_profile_check;
|
|
extern AVBufferRef *hw_device_ctx;
|
|
|
|
void reset_options(OptionsContext *o);
|
|
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);
|
|
|
|
int configure_filtergraph(FilterGraph *fg);
|
|
int configure_output_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out);
|
|
int ist_in_filtergraph(FilterGraph *fg, InputStream *ist);
|
|
int filtergraph_is_simple(FilterGraph *fg);
|
|
int init_simple_filtergraph(InputStream *ist, OutputStream *ost);
|
|
int init_complex_filtergraph(FilterGraph *fg);
|
|
|
|
int ifilter_parameters_from_frame(InputFilter *ifilter, const AVFrame *frame);
|
|
|
|
int avconv_parse_options(int argc, char **argv);
|
|
|
|
int vdpau_init(AVCodecContext *s);
|
|
int dxva2_init(AVCodecContext *s);
|
|
int vda_init(AVCodecContext *s);
|
|
int qsv_init(AVCodecContext *s);
|
|
int qsv_transcode_init(OutputStream *ost);
|
|
int vaapi_decode_init(AVCodecContext *avctx);
|
|
int vaapi_device_init(const char *device);
|
|
|
|
#endif /* AVCONV_H */
|