2012-08-01 19:23:12 +03:00
|
|
|
/*
|
2012-08-09 01:26:38 +03:00
|
|
|
* This file is part of FFmpeg.
|
2012-08-01 19:23:12 +03:00
|
|
|
*
|
2012-08-09 01:26:38 +03:00
|
|
|
* FFmpeg is free software; you can redistribute it and/or
|
2012-08-01 19:23:12 +03:00
|
|
|
* 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.
|
|
|
|
*
|
2012-08-09 01:26:38 +03:00
|
|
|
* FFmpeg is distributed in the hope that it will be useful,
|
2012-08-01 19:23:12 +03:00
|
|
|
* 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
|
2012-08-09 01:26:38 +03:00
|
|
|
* License along with FFmpeg; if not, write to the Free Software
|
2012-08-01 19:23:12 +03:00
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
*/
|
|
|
|
|
2017-10-01 23:21:02 +02:00
|
|
|
#ifndef FFTOOLS_FFMPEG_H
|
|
|
|
#define FFTOOLS_FFMPEG_H
|
2012-08-01 19:23:12 +03:00
|
|
|
|
|
|
|
#include "config.h"
|
|
|
|
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <stdio.h>
|
2012-08-09 01:26:38 +03:00
|
|
|
#include <signal.h>
|
2012-08-01 19:23:12 +03:00
|
|
|
|
|
|
|
#include "cmdutils.h"
|
|
|
|
|
|
|
|
#include "libavformat/avformat.h"
|
|
|
|
#include "libavformat/avio.h"
|
|
|
|
|
|
|
|
#include "libavcodec/avcodec.h"
|
2021-06-11 23:35:33 +02:00
|
|
|
#include "libavcodec/bsf.h"
|
2012-08-01 19:23:12 +03:00
|
|
|
|
|
|
|
#include "libavfilter/avfilter.h"
|
|
|
|
|
|
|
|
#include "libavutil/avutil.h"
|
|
|
|
#include "libavutil/dict.h"
|
2012-12-09 20:40:22 +03:00
|
|
|
#include "libavutil/eval.h"
|
2012-08-01 19:23:12 +03:00
|
|
|
#include "libavutil/fifo.h"
|
2017-03-05 01:57:30 +02:00
|
|
|
#include "libavutil/hwcontext.h"
|
2012-08-01 19:23:12 +03:00
|
|
|
#include "libavutil/pixfmt.h"
|
|
|
|
#include "libavutil/rational.h"
|
2018-01-04 05:46:33 +02:00
|
|
|
#include "libavutil/thread.h"
|
2014-02-20 16:14:53 +03:00
|
|
|
#include "libavutil/threadmessage.h"
|
2012-08-01 19:23:12 +03:00
|
|
|
|
2012-08-09 01:26:38 +03:00
|
|
|
#include "libswresample/swresample.h"
|
|
|
|
|
2021-12-04 15:53:58 +02:00
|
|
|
enum VideoSyncMethod {
|
|
|
|
VSYNC_AUTO = -1,
|
|
|
|
VSYNC_PASSTHROUGH,
|
|
|
|
VSYNC_CFR,
|
|
|
|
VSYNC_VFR,
|
|
|
|
VSYNC_VSCFR,
|
|
|
|
VSYNC_DROP,
|
|
|
|
};
|
2012-08-09 01:26:38 +03:00
|
|
|
|
|
|
|
#define MAX_STREAMS 1024 /* arbitrary sanity check value */
|
2012-08-01 19:23:12 +03:00
|
|
|
|
2013-11-03 00:06:36 +03:00
|
|
|
enum HWAccelID {
|
|
|
|
HWACCEL_NONE = 0,
|
|
|
|
HWACCEL_AUTO,
|
2017-10-26 01:18:47 +02:00
|
|
|
HWACCEL_GENERIC,
|
2013-11-03 00:06:36 +03:00
|
|
|
};
|
|
|
|
|
2017-03-05 01:57:30 +02:00
|
|
|
typedef struct HWDevice {
|
2019-05-06 16:29:01 +02:00
|
|
|
const char *name;
|
2017-03-05 01:57:30 +02:00
|
|
|
enum AVHWDeviceType type;
|
|
|
|
AVBufferRef *device_ref;
|
|
|
|
} HWDevice;
|
|
|
|
|
2012-08-01 19:23:12 +03:00
|
|
|
/* select an input stream for an output stream */
|
|
|
|
typedef struct StreamMap {
|
2012-08-24 14:31:50 +03:00
|
|
|
int disabled; /* 1 is this mapping is disabled by a negative map */
|
2012-08-01 19:23:12 +03:00
|
|
|
int file_index;
|
|
|
|
int stream_index;
|
|
|
|
int sync_file_index;
|
|
|
|
int sync_stream_index;
|
2012-08-24 14:31:50 +03:00
|
|
|
char *linklabel; /* name of an output link, for mapping lavfi outputs */
|
2012-08-01 19:23:12 +03:00
|
|
|
} StreamMap;
|
|
|
|
|
2012-08-09 01:26:38 +03:00
|
|
|
typedef struct {
|
|
|
|
int file_idx, stream_idx, channel_idx; // input
|
|
|
|
int ofile_idx, ostream_idx; // output
|
|
|
|
} AudioChannelMap;
|
2012-08-01 19:23:12 +03:00
|
|
|
|
|
|
|
typedef struct OptionsContext {
|
2012-06-08 22:35:16 +03:00
|
|
|
OptionGroup *g;
|
|
|
|
|
2012-08-01 19:23:12 +03:00
|
|
|
/* input/output options */
|
|
|
|
int64_t start_time;
|
2015-07-27 04:30:26 +02:00
|
|
|
int64_t start_time_eof;
|
2015-04-20 19:36:51 +02:00
|
|
|
int seek_timestamp;
|
2012-08-01 19:23:12 +03:00
|
|
|
const char *format;
|
|
|
|
|
|
|
|
SpecifierOpt *codec_names;
|
|
|
|
int nb_codec_names;
|
2022-03-18 21:55:58 +02:00
|
|
|
SpecifierOpt *audio_ch_layouts;
|
|
|
|
int nb_audio_ch_layouts;
|
2012-08-01 19:23:12 +03:00
|
|
|
SpecifierOpt *audio_channels;
|
|
|
|
int nb_audio_channels;
|
|
|
|
SpecifierOpt *audio_sample_rate;
|
|
|
|
int nb_audio_sample_rate;
|
|
|
|
SpecifierOpt *frame_rates;
|
|
|
|
int nb_frame_rates;
|
2021-02-01 14:49:18 +02:00
|
|
|
SpecifierOpt *max_frame_rates;
|
|
|
|
int nb_max_frame_rates;
|
2012-08-01 19:23:12 +03:00
|
|
|
SpecifierOpt *frame_sizes;
|
|
|
|
int nb_frame_sizes;
|
|
|
|
SpecifierOpt *frame_pix_fmts;
|
|
|
|
int nb_frame_pix_fmts;
|
|
|
|
|
|
|
|
/* input options */
|
|
|
|
int64_t input_ts_offset;
|
2015-10-09 22:11:56 +02:00
|
|
|
int loop;
|
2012-08-01 19:23:12 +03:00
|
|
|
int rate_emu;
|
2021-07-16 14:29:39 +02:00
|
|
|
float readrate;
|
2013-06-15 10:59:40 +03:00
|
|
|
int accurate_seek;
|
2015-02-25 12:50:44 +02:00
|
|
|
int thread_queue_size;
|
2012-08-01 19:23:12 +03:00
|
|
|
|
|
|
|
SpecifierOpt *ts_scale;
|
|
|
|
int nb_ts_scale;
|
|
|
|
SpecifierOpt *dump_attachment;
|
|
|
|
int nb_dump_attachment;
|
2013-11-03 00:06:36 +03:00
|
|
|
SpecifierOpt *hwaccels;
|
|
|
|
int nb_hwaccels;
|
|
|
|
SpecifierOpt *hwaccel_devices;
|
|
|
|
int nb_hwaccel_devices;
|
2016-03-24 01:48:13 +02:00
|
|
|
SpecifierOpt *hwaccel_output_formats;
|
|
|
|
int nb_hwaccel_output_formats;
|
2015-04-29 16:59:01 +02:00
|
|
|
SpecifierOpt *autorotate;
|
|
|
|
int nb_autorotate;
|
2012-08-01 19:23:12 +03:00
|
|
|
|
|
|
|
/* output options */
|
|
|
|
StreamMap *stream_maps;
|
|
|
|
int nb_stream_maps;
|
2012-08-09 01:26:38 +03:00
|
|
|
AudioChannelMap *audio_channel_maps; /* one info entry per -map_channel */
|
|
|
|
int nb_audio_channel_maps; /* number of (valid) -map_channel settings */
|
2012-08-01 19:23:12 +03:00
|
|
|
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;
|
2013-02-27 02:18:41 +03:00
|
|
|
int64_t stop_time;
|
2012-08-01 19:23:12 +03:00
|
|
|
uint64_t limit_filesize;
|
|
|
|
float mux_preload;
|
|
|
|
float mux_max_delay;
|
2012-08-11 12:50:32 +03:00
|
|
|
int shortest;
|
2017-10-22 01:41:57 +02:00
|
|
|
int bitexact;
|
2012-08-01 19:23:12 +03:00
|
|
|
|
|
|
|
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;
|
2014-02-10 21:02:01 +03:00
|
|
|
SpecifierOpt *chroma_intra_matrices;
|
|
|
|
int nb_chroma_intra_matrices;
|
2012-08-01 19:23:12 +03:00
|
|
|
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;
|
2012-09-27 04:37:27 +03:00
|
|
|
SpecifierOpt *copy_prior_start;
|
|
|
|
int nb_copy_prior_start;
|
2012-08-01 19:23:12 +03:00
|
|
|
SpecifierOpt *filters;
|
|
|
|
int nb_filters;
|
2013-03-13 16:24:45 +03:00
|
|
|
SpecifierOpt *filter_scripts;
|
|
|
|
int nb_filter_scripts;
|
2012-10-17 00:50:06 +03:00
|
|
|
SpecifierOpt *reinit_filters;
|
|
|
|
int nb_reinit_filters;
|
2012-08-09 12:44:17 +03:00
|
|
|
SpecifierOpt *fix_sub_duration;
|
|
|
|
int nb_fix_sub_duration;
|
2013-02-27 23:14:48 +03:00
|
|
|
SpecifierOpt *canvas_sizes;
|
|
|
|
int nb_canvas_sizes;
|
2012-08-19 09:29:44 +03:00
|
|
|
SpecifierOpt *pass;
|
|
|
|
int nb_pass;
|
2012-08-19 10:15:48 +03:00
|
|
|
SpecifierOpt *passlogfiles;
|
|
|
|
int nb_passlogfiles;
|
2016-05-23 10:48:26 +02:00
|
|
|
SpecifierOpt *max_muxing_queue_size;
|
|
|
|
int nb_max_muxing_queue_size;
|
2020-10-15 20:21:05 +02:00
|
|
|
SpecifierOpt *muxing_queue_data_threshold;
|
|
|
|
int nb_muxing_queue_data_threshold;
|
2012-12-31 17:20:25 +03:00
|
|
|
SpecifierOpt *guess_layout_max;
|
|
|
|
int nb_guess_layout_max;
|
2013-05-09 00:43:19 +03:00
|
|
|
SpecifierOpt *apad;
|
|
|
|
int nb_apad;
|
2014-05-31 06:53:06 +03:00
|
|
|
SpecifierOpt *discard;
|
|
|
|
int nb_discard;
|
2015-01-08 23:51:25 +02:00
|
|
|
SpecifierOpt *disposition;
|
|
|
|
int nb_disposition;
|
2015-12-10 22:01:19 +02:00
|
|
|
SpecifierOpt *program;
|
|
|
|
int nb_program;
|
2016-12-28 08:05:35 +02:00
|
|
|
SpecifierOpt *time_bases;
|
|
|
|
int nb_time_bases;
|
2017-05-03 10:50:15 +02:00
|
|
|
SpecifierOpt *enc_time_bases;
|
|
|
|
int nb_enc_time_bases;
|
2020-06-08 10:58:05 +02:00
|
|
|
SpecifierOpt *autoscale;
|
|
|
|
int nb_autoscale;
|
2021-11-23 11:18:01 +02:00
|
|
|
SpecifierOpt *bits_per_raw_sample;
|
|
|
|
int nb_bits_per_raw_sample;
|
2012-08-01 19:23:12 +03:00
|
|
|
} OptionsContext;
|
|
|
|
|
|
|
|
typedef struct InputFilter {
|
|
|
|
AVFilterContext *filter;
|
|
|
|
struct InputStream *ist;
|
|
|
|
struct FilterGraph *graph;
|
|
|
|
uint8_t *name;
|
2016-05-27 12:14:33 +02:00
|
|
|
enum AVMediaType type; // AVMEDIA_TYPE_SUBTITLE for sub2video
|
|
|
|
|
2022-01-10 12:04:36 +02:00
|
|
|
AVFifo *frame_queue;
|
2016-05-23 14:09:08 +02:00
|
|
|
|
|
|
|
// parameters configured for this input
|
|
|
|
int format;
|
|
|
|
|
|
|
|
int width, height;
|
|
|
|
AVRational sample_aspect_ratio;
|
|
|
|
|
|
|
|
int sample_rate;
|
2021-09-03 02:04:30 +02:00
|
|
|
AVChannelLayout ch_layout;
|
2016-05-23 14:09:08 +02:00
|
|
|
|
|
|
|
AVBufferRef *hw_frames_ctx;
|
2021-09-08 20:34:25 +02:00
|
|
|
int32_t *displaymatrix;
|
2016-06-27 19:03:42 +02:00
|
|
|
|
|
|
|
int eof;
|
2012-08-01 19:23:12 +03:00
|
|
|
} 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;
|
2015-07-15 19:49:24 +02:00
|
|
|
enum AVMediaType type;
|
2016-05-23 14:09:08 +02:00
|
|
|
|
|
|
|
/* desired output stream properties */
|
|
|
|
int width, height;
|
|
|
|
AVRational frame_rate;
|
|
|
|
int format;
|
|
|
|
int sample_rate;
|
2021-09-03 02:04:30 +02:00
|
|
|
AVChannelLayout ch_layout;
|
2016-05-23 14:09:08 +02:00
|
|
|
|
|
|
|
// those are only set if no format is specified and the encoder gives us multiple options
|
2021-11-26 20:44:21 +02:00
|
|
|
// They point directly to the relevant lists of the encoder.
|
|
|
|
const int *formats;
|
2021-09-03 02:04:30 +02:00
|
|
|
const AVChannelLayout *ch_layouts;
|
2021-11-26 20:44:21 +02:00
|
|
|
const int *sample_rates;
|
2012-08-01 19:23:12 +03:00
|
|
|
} OutputFilter;
|
|
|
|
|
|
|
|
typedef struct FilterGraph {
|
|
|
|
int index;
|
|
|
|
const char *graph_desc;
|
|
|
|
|
|
|
|
AVFilterGraph *graph;
|
2013-02-25 05:00:58 +03:00
|
|
|
int reconfiguration;
|
2021-11-23 12:22:57 +02:00
|
|
|
// true when the filtergraph contains only meta filters
|
|
|
|
// that do not modify the frame data
|
|
|
|
int is_meta;
|
2012-08-01 19:23:12 +03:00
|
|
|
|
|
|
|
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 */
|
2014-05-31 06:53:06 +03:00
|
|
|
int user_set_discard;
|
2014-09-01 05:13:49 +03:00
|
|
|
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
|
2022-02-14 19:07:01 +02:00
|
|
|
int processing_needed; /* non zero if the packets must be processed */
|
2014-09-01 05:13:49 +03:00
|
|
|
|
2014-04-05 09:48:24 +03:00
|
|
|
AVCodecContext *dec_ctx;
|
2021-02-25 06:02:39 +02:00
|
|
|
const AVCodec *dec;
|
2012-08-01 19:23:12 +03:00
|
|
|
AVFrame *decoded_frame;
|
2021-01-30 00:09:18 +02:00
|
|
|
AVPacket *pkt;
|
2012-08-01 19:23:12 +03:00
|
|
|
|
2021-08-25 13:08:10 +02:00
|
|
|
int64_t prev_pkt_pts;
|
2012-08-01 19:23:12 +03:00
|
|
|
int64_t start; /* time when read started */
|
|
|
|
/* predicted dts of the next packet read for this stream or (when there are
|
2012-08-09 01:26:38 +03:00
|
|
|
* several frames in a packet) of the next frame in current packet (in AV_TIME_BASE units) */
|
2012-08-01 19:23:12 +03:00
|
|
|
int64_t next_dts;
|
2021-05-31 22:15:56 +02:00
|
|
|
int64_t first_dts; ///< dts of the first packet read for this stream (in AV_TIME_BASE units)
|
2012-08-09 01:26:38 +03:00
|
|
|
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;
|
2012-10-26 22:55:37 +03:00
|
|
|
|
|
|
|
int64_t filter_in_rescale_delta_last;
|
2015-10-22 05:26:46 +02:00
|
|
|
|
2015-10-09 22:11:56 +02:00
|
|
|
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 */
|
2016-07-15 06:50:47 +02:00
|
|
|
|
|
|
|
// when forcing constant input framerate through -r,
|
|
|
|
// this contains the pts that will be given to the next decoded frame
|
|
|
|
int64_t cfr_next_pts;
|
|
|
|
|
2015-10-09 22:11:56 +02:00
|
|
|
int64_t nb_samples; /* number of samples in the last decoded audio frame before looping */
|
2012-10-26 22:55:37 +03:00
|
|
|
|
2012-08-01 19:23:12 +03:00
|
|
|
double ts_scale;
|
2012-08-09 01:26:38 +03:00
|
|
|
int saw_first_ts;
|
2014-04-04 20:38:04 +03:00
|
|
|
AVDictionary *decoder_opts;
|
2012-08-01 19:23:12 +03:00
|
|
|
AVRational framerate; /* framerate forced with -r */
|
2012-08-09 01:26:38 +03:00
|
|
|
int top_field_first;
|
2012-12-31 17:20:25 +03:00
|
|
|
int guess_layout_max;
|
2012-08-01 19:23:12 +03:00
|
|
|
|
2015-04-29 16:59:01 +02:00
|
|
|
int autorotate;
|
2012-08-01 19:23:12 +03:00
|
|
|
|
2012-08-09 12:44:17 +03:00
|
|
|
int fix_sub_duration;
|
|
|
|
struct { /* previous decoded subtitle and related variables */
|
|
|
|
int got_output;
|
|
|
|
int ret;
|
|
|
|
AVSubtitle subtitle;
|
|
|
|
} prev_sub;
|
|
|
|
|
2012-08-09 01:26:38 +03:00
|
|
|
struct sub2video {
|
|
|
|
int64_t last_pts;
|
2012-11-29 22:25:37 +03:00
|
|
|
int64_t end_pts;
|
2022-01-10 12:04:36 +02:00
|
|
|
AVFifo *sub_queue; ///< queue of AVSubtitle* before filter init
|
2013-03-10 13:51:02 +03:00
|
|
|
AVFrame *frame;
|
2012-08-09 01:26:38 +03:00
|
|
|
int w, h;
|
2019-02-23 01:48:08 +02:00
|
|
|
unsigned int initialize; ///< marks if sub2video_update should force an initialization
|
2012-08-09 01:26:38 +03:00
|
|
|
} sub2video;
|
|
|
|
|
2012-08-01 19:23:12 +03:00
|
|
|
/* decoded data from this stream goes into all those filters
|
|
|
|
* currently video and audio only */
|
|
|
|
InputFilter **filters;
|
|
|
|
int nb_filters;
|
2012-10-17 00:50:06 +03:00
|
|
|
|
|
|
|
int reinit_filters;
|
2013-11-23 16:26:27 +03:00
|
|
|
|
2013-11-03 00:06:36 +03:00
|
|
|
/* hwaccel options */
|
|
|
|
enum HWAccelID hwaccel_id;
|
2017-10-26 01:18:47 +02:00
|
|
|
enum AVHWDeviceType hwaccel_device_type;
|
2013-11-03 00:06:36 +03:00
|
|
|
char *hwaccel_device;
|
2016-03-24 01:48:13 +02:00
|
|
|
enum AVPixelFormat hwaccel_output_format;
|
2013-11-03 00:06:36 +03:00
|
|
|
|
|
|
|
/* hwaccel context */
|
|
|
|
void *hwaccel_ctx;
|
|
|
|
void (*hwaccel_uninit)(AVCodecContext *s);
|
|
|
|
int (*hwaccel_retrieve_data)(AVCodecContext *s, AVFrame *frame);
|
|
|
|
enum AVPixelFormat hwaccel_pix_fmt;
|
|
|
|
enum AVPixelFormat hwaccel_retrieved_pix_fmt;
|
2014-03-17 12:58:05 +03:00
|
|
|
|
|
|
|
/* 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;
|
2016-10-01 17:22:15 +02:00
|
|
|
|
|
|
|
int64_t *dts_buffer;
|
|
|
|
int nb_dts_buffer;
|
2016-05-27 12:14:33 +02:00
|
|
|
|
|
|
|
int got_output;
|
2012-08-01 19:23:12 +03:00
|
|
|
} InputStream;
|
|
|
|
|
|
|
|
typedef struct InputFile {
|
|
|
|
AVFormatContext *ctx;
|
|
|
|
int eof_reached; /* true if eof reached */
|
2012-08-04 13:04:02 +03:00
|
|
|
int eagain; /* true if last read attempt returned EAGAIN */
|
2012-08-09 01:26:38 +03:00
|
|
|
int ist_index; /* index of first stream in input_streams */
|
2015-10-09 22:11:56 +02:00
|
|
|
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 */
|
2013-11-14 03:21:20 +03:00
|
|
|
int64_t input_ts_offset;
|
2015-10-22 05:26:46 +02:00
|
|
|
|
2012-08-01 19:23:12 +03:00
|
|
|
int64_t ts_offset;
|
2013-03-23 06:30:19 +03:00
|
|
|
int64_t last_ts;
|
2013-06-15 10:59:40 +03:00
|
|
|
int64_t start_time; /* user-specified start time in AV_TIME_BASE or AV_NOPTS_VALUE */
|
2013-06-18 12:12:09 +03:00
|
|
|
int64_t recording_time;
|
2012-08-09 01:26:38 +03:00
|
|
|
int nb_streams; /* number of stream that ffmpeg is aware of; may be different
|
2012-08-01 19:23:12 +03:00
|
|
|
from ctx.nb_streams if new streams appear during av_read_frame() */
|
2012-08-09 01:26:38 +03:00
|
|
|
int nb_streams_warn; /* number of streams that the user was warned of */
|
2012-08-01 19:23:12 +03:00
|
|
|
int rate_emu;
|
2021-07-16 14:29:39 +02:00
|
|
|
float readrate;
|
2013-06-15 10:59:40 +03:00
|
|
|
int accurate_seek;
|
2012-08-01 19:23:12 +03:00
|
|
|
|
2021-01-30 00:09:18 +02:00
|
|
|
AVPacket *pkt;
|
|
|
|
|
2018-01-04 05:46:33 +02:00
|
|
|
#if HAVE_THREADS
|
2014-02-20 16:14:53 +03:00
|
|
|
AVThreadMessageQueue *in_thread_queue;
|
2012-08-01 19:23:12 +03:00
|
|
|
pthread_t thread; /* thread reading from this file */
|
2013-10-25 11:58:14 +03:00
|
|
|
int non_blocking; /* reading packets from the thread should not block */
|
2012-08-01 19:23:12 +03:00
|
|
|
int joined; /* the thread has been joined */
|
2015-02-25 12:50:44 +02:00
|
|
|
int thread_queue_size; /* maximum number of queued packets */
|
2012-08-01 19:23:12 +03:00
|
|
|
#endif
|
|
|
|
} InputFile;
|
|
|
|
|
2012-12-09 20:40:22 +03:00
|
|
|
enum forced_keyframes_const {
|
|
|
|
FKF_N,
|
|
|
|
FKF_N_FORCED,
|
|
|
|
FKF_PREV_FORCED_N,
|
|
|
|
FKF_PREV_FORCED_T,
|
|
|
|
FKF_T,
|
|
|
|
FKF_NB
|
|
|
|
};
|
|
|
|
|
2020-05-13 00:06:08 +02:00
|
|
|
#define ABORT_ON_FLAG_EMPTY_OUTPUT (1 << 0)
|
|
|
|
#define ABORT_ON_FLAG_EMPTY_OUTPUT_STREAM (1 << 1)
|
2015-10-17 23:46:09 +02:00
|
|
|
|
2012-12-09 20:40:22 +03:00
|
|
|
extern const char *const forced_keyframes_const_names[];
|
|
|
|
|
2014-01-18 01:52:55 +03:00
|
|
|
typedef enum {
|
|
|
|
ENCODER_FINISHED = 1,
|
|
|
|
MUXER_FINISHED = 2,
|
|
|
|
} OSTFinished ;
|
|
|
|
|
2012-08-01 19:23:12 +03:00
|
|
|
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;
|
2013-04-24 09:34:44 +03:00
|
|
|
/* dts of the last packet sent to the muxer */
|
|
|
|
int64_t last_mux_dts;
|
2016-05-27 12:04:29 +02:00
|
|
|
// the timebase of the packets sent to the muxer
|
|
|
|
AVRational mux_timebase;
|
2017-05-03 10:50:15 +02:00
|
|
|
AVRational enc_timebase;
|
2016-09-21 15:39:16 +02:00
|
|
|
|
2020-04-17 23:55:55 +02:00
|
|
|
AVBSFContext *bsf_ctx;
|
2016-09-21 15:39:16 +02:00
|
|
|
|
2014-04-05 09:48:24 +03:00
|
|
|
AVCodecContext *enc_ctx;
|
2016-09-01 16:48:45 +02:00
|
|
|
AVCodecParameters *ref_par; /* associated input codec parameters with encoders options applied */
|
2021-02-25 06:02:39 +02:00
|
|
|
const AVCodec *enc;
|
2012-08-01 19:23:12 +03:00
|
|
|
int64_t max_frames;
|
|
|
|
AVFrame *filtered_frame;
|
2014-11-19 04:10:12 +02:00
|
|
|
AVFrame *last_frame;
|
2021-01-30 00:09:18 +02:00
|
|
|
AVPacket *pkt;
|
2015-11-15 04:23:20 +02:00
|
|
|
int last_dropped;
|
2014-11-19 13:41:16 +02:00
|
|
|
int last_nb0_frames[3];
|
2012-08-01 19:23:12 +03:00
|
|
|
|
2015-10-13 14:11:35 +02:00
|
|
|
void *hwaccel_ctx;
|
|
|
|
|
2012-08-01 19:23:12 +03:00
|
|
|
/* video only */
|
|
|
|
AVRational frame_rate;
|
2021-02-01 14:49:18 +02:00
|
|
|
AVRational max_frame_rate;
|
2021-12-04 16:16:54 +02:00
|
|
|
enum VideoSyncMethod vsync_method;
|
2015-11-10 23:53:29 +02:00
|
|
|
int is_cfr;
|
2012-08-01 19:23:12 +03:00
|
|
|
int force_fps;
|
|
|
|
int top_field_first;
|
2015-05-18 00:28:57 +02:00
|
|
|
int rotate_overridden;
|
2020-06-08 10:58:05 +02:00
|
|
|
int autoscale;
|
2021-11-23 11:18:01 +02:00
|
|
|
int bits_per_raw_sample;
|
avformat, ffmpeg: deprecate old rotation API
The old "API" that signaled rotation as a metadata value has been
replaced by DISPLAYMATRIX side data quite a while ago.
There is no reason to make muxers/demuxers/API users support both. In
addition, the metadata API is dangerous, as user tags could "leak" into
it, creating unintended features or bugs.
ffmpeg CLI has to be updated to use the new API. In particular, we must
not allow to leak the "rotate" tag into the muxer. Some muxers will
catch this properly (like mov), but others (like mkv) can add it as
generic tag. Note applications, which use libavformat and assume the
old rotate API, will interpret such "rotate" user tags as rotate
metadata (which it is not), and incorrectly rotate the video.
The ffmpeg/ffplay tools drop the use of the old API for muxing and
demuxing, as all muxers/demuxers support the new API. This will mean
that the tools will not mistakenly interpret per-track "rotate" user
tags as rotate metadata. It will _not_ be treated as regression.
Unfortunately, hacks have been added, that allow the user to override
rotation by setting metadata explicitly, e.g. via
-metadata:s:v:0 rotate=0
See references to trac #4560. fate-filter-meta-4560-rotate0 tests this.
It's easier to adjust the hack for supporting it than arguing for its
removal, so ffmpeg CLI now explicitly catches this case, and essentially
replaces the "rotate" value with a display matrix side data. (It would
be easier for both user and implementation to create an explicit option
for rotation.)
When the code under FF_API_OLD_ROTATE_API is disabled, one FATE
reference file has to be updated (because "rotate" is not exported
anymore).
Tested-by: Michael Niedermayer <michael@niedermayer.cc>
Reviewed-by: Michael Niedermayer <michael@niedermayer.cc>
2017-03-21 09:02:58 +02:00
|
|
|
double rotate_override_value;
|
2012-08-01 19:23:12 +03:00
|
|
|
|
2013-04-09 12:43:08 +03:00
|
|
|
AVRational frame_aspect_ratio;
|
2012-08-01 19:23:12 +03:00
|
|
|
|
|
|
|
/* forced key frames */
|
2018-05-06 19:08:59 +02:00
|
|
|
int64_t forced_kf_ref_pts;
|
2012-08-01 19:23:12 +03:00
|
|
|
int64_t *forced_kf_pts;
|
|
|
|
int forced_kf_count;
|
|
|
|
int forced_kf_index;
|
|
|
|
char *forced_keyframes;
|
2012-12-09 20:40:22 +03:00
|
|
|
AVExpr *forced_keyframes_pexpr;
|
|
|
|
double forced_keyframes_expr_const_values[FKF_NB];
|
2021-06-20 21:42:29 +02:00
|
|
|
int dropped_keyframe;
|
2012-08-01 19:23:12 +03:00
|
|
|
|
2012-08-09 01:26:38 +03:00
|
|
|
/* audio only */
|
2014-08-15 05:46:24 +03:00
|
|
|
int *audio_channels_map; /* list of the channels id to pick from the source stream */
|
2012-08-09 01:26:38 +03:00
|
|
|
int audio_channels_mapped; /* number of channels in audio_channels_map */
|
|
|
|
|
2012-08-19 10:15:48 +03:00
|
|
|
char *logfile_prefix;
|
2012-08-01 19:23:12 +03:00
|
|
|
FILE *logfile;
|
|
|
|
|
|
|
|
OutputFilter *filter;
|
|
|
|
char *avfilter;
|
2013-11-04 12:02:27 +03:00
|
|
|
char *filters; ///< filtergraph associated to the -filter option
|
|
|
|
char *filters_script; ///< filtergraph script associated to the -filter_script option
|
2012-08-01 19:23:12 +03:00
|
|
|
|
2014-04-04 20:38:04 +03:00
|
|
|
AVDictionary *encoder_opts;
|
2015-08-08 13:33:46 +02:00
|
|
|
AVDictionary *sws_dict;
|
2013-02-24 21:07:42 +03:00
|
|
|
AVDictionary *swr_opts;
|
2013-05-09 00:43:19 +03:00
|
|
|
char *apad;
|
2014-01-18 01:52:55 +03:00
|
|
|
OSTFinished finished; /* no more packets should be written for this stream */
|
2012-08-09 01:26:38 +03:00
|
|
|
int unavailable; /* true if the steram is unavailable (possibly temporarily) */
|
2012-08-01 19:23:12 +03:00
|
|
|
int stream_copy;
|
2016-05-23 09:19:25 +02:00
|
|
|
|
|
|
|
// init_output_stream() has been called for this stream
|
2016-10-07 16:05:09 +02:00
|
|
|
// The encoder and the bitstream filters have been initialized and the stream
|
2016-05-23 09:19:25 +02:00
|
|
|
// parameters are set in the AVStream.
|
|
|
|
int initialized;
|
|
|
|
|
2016-05-27 12:14:33 +02:00
|
|
|
int inputs_done;
|
|
|
|
|
2012-08-01 19:23:12 +03:00
|
|
|
const char *attachment_filename;
|
2022-03-31 16:34:29 +02:00
|
|
|
int streamcopy_started;
|
2012-08-01 19:23:12 +03:00
|
|
|
int copy_initial_nonkeyframes;
|
2012-09-27 04:37:27 +03:00
|
|
|
int copy_prior_start;
|
2015-01-08 23:51:25 +02:00
|
|
|
char *disposition;
|
2012-08-01 19:23:12 +03:00
|
|
|
|
2012-08-09 01:26:38 +03:00
|
|
|
int keep_pix_fmt;
|
2013-10-28 17:10:21 +03:00
|
|
|
|
2014-03-17 12:03:47 +03:00
|
|
|
/* stats */
|
|
|
|
// combined size of all the packets written
|
|
|
|
uint64_t data_size;
|
2014-03-17 12:58:05 +03:00
|
|
|
// 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;
|
2021-12-16 12:10:58 +02:00
|
|
|
// number of packets received from the encoder
|
|
|
|
uint64_t packets_encoded;
|
2015-07-15 19:41:21 +02:00
|
|
|
|
|
|
|
/* packet quality factor */
|
|
|
|
int quality;
|
2015-07-28 01:28:34 +02:00
|
|
|
|
2016-05-23 10:48:26 +02:00
|
|
|
int max_muxing_queue_size;
|
|
|
|
|
|
|
|
/* the packets are buffered here until the muxer is ready to be initialized */
|
2022-01-10 12:04:36 +02:00
|
|
|
AVFifo *muxing_queue;
|
2016-10-08 11:38:47 +02:00
|
|
|
|
2020-10-15 20:21:05 +02:00
|
|
|
/*
|
|
|
|
* The size of the AVPackets' buffers in queue.
|
|
|
|
* Updated when a packet is either pushed or pulled from the queue.
|
|
|
|
*/
|
|
|
|
size_t muxing_queue_data_size;
|
|
|
|
|
|
|
|
/* Threshold after which max_muxing_queue_size will be in effect */
|
|
|
|
size_t muxing_queue_data_threshold;
|
|
|
|
|
2015-07-28 19:42:00 +02:00
|
|
|
/* packet picture type */
|
|
|
|
int pict_type;
|
|
|
|
|
2015-07-28 01:28:34 +02:00
|
|
|
/* frame encode sum of squared error values */
|
|
|
|
int64_t error[4];
|
2012-08-01 19:23:12 +03:00
|
|
|
} OutputStream;
|
|
|
|
|
|
|
|
typedef struct OutputFile {
|
2021-12-11 14:22:36 +02:00
|
|
|
int index;
|
|
|
|
|
2021-11-11 11:35:15 +02:00
|
|
|
const AVOutputFormat *format;
|
|
|
|
|
2012-08-01 19:23:12 +03:00
|
|
|
AVFormatContext *ctx;
|
|
|
|
AVDictionary *opts;
|
|
|
|
int ost_index; /* index of the first stream in output_streams */
|
2012-08-09 01:26:38 +03:00
|
|
|
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 */
|
2012-08-11 12:50:32 +03:00
|
|
|
|
|
|
|
int shortest;
|
2016-05-23 09:19:25 +02:00
|
|
|
|
|
|
|
int header_written;
|
2012-08-01 19:23:12 +03:00
|
|
|
} 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;
|
2014-12-25 23:56:06 +02:00
|
|
|
extern char *sdp_filename;
|
2012-08-01 19:23:12 +03:00
|
|
|
|
|
|
|
extern float audio_drift_threshold;
|
|
|
|
extern float dts_delta_threshold;
|
2012-08-09 01:26:38 +03:00
|
|
|
extern float dts_error_threshold;
|
2012-08-01 19:23:12 +03:00
|
|
|
|
|
|
|
extern int audio_volume;
|
|
|
|
extern int audio_sync_method;
|
2021-12-04 15:53:58 +02:00
|
|
|
extern enum VideoSyncMethod video_sync_method;
|
2015-01-17 05:38:32 +02:00
|
|
|
extern float frame_drop_threshold;
|
2012-08-01 19:23:12 +03:00
|
|
|
extern int do_benchmark;
|
2012-08-09 01:26:38 +03:00
|
|
|
extern int do_benchmark_all;
|
2012-08-01 19:23:12 +03:00
|
|
|
extern int do_deinterlace;
|
|
|
|
extern int do_hex_dump;
|
|
|
|
extern int do_pkt_dump;
|
|
|
|
extern int copy_ts;
|
2014-11-24 07:31:20 +02:00
|
|
|
extern int start_at_zero;
|
2012-08-01 19:23:12 +03:00
|
|
|
extern int copy_tb;
|
2012-08-09 01:26:38 +03:00
|
|
|
extern int debug_ts;
|
2012-08-01 19:23:12 +03:00
|
|
|
extern int exit_on_error;
|
2015-10-17 23:46:09 +02:00
|
|
|
extern int abort_on_flags;
|
2012-08-01 19:23:12 +03:00
|
|
|
extern int print_stats;
|
2020-12-21 10:46:49 +02:00
|
|
|
extern int64_t stats_period;
|
2012-08-01 19:23:12 +03:00
|
|
|
extern int qp_hist;
|
2012-08-09 01:26:38 +03:00
|
|
|
extern int stdin_interaction;
|
|
|
|
extern int frame_bits_per_raw_sample;
|
|
|
|
extern AVIOContext *progress_avio;
|
2013-10-01 19:17:16 +03:00
|
|
|
extern float max_error_rate;
|
2012-08-01 19:23:12 +03:00
|
|
|
|
2021-09-03 15:30:32 +02:00
|
|
|
extern char *filter_nbthreads;
|
2016-10-30 15:25:39 +02:00
|
|
|
extern int filter_complex_nbthreads;
|
2017-01-24 18:23:54 +02:00
|
|
|
extern int vstats_version;
|
2020-08-14 13:06:34 +02:00
|
|
|
extern int auto_conversion_filters;
|
2016-10-30 15:25:39 +02:00
|
|
|
|
2012-08-01 19:23:12 +03:00
|
|
|
extern const AVIOInterruptCB int_cb;
|
|
|
|
|
|
|
|
extern const OptionDef options[];
|
2017-01-05 08:48:06 +02:00
|
|
|
#if CONFIG_QSV
|
|
|
|
extern char *qsv_device;
|
|
|
|
#endif
|
2017-03-05 01:57:38 +02:00
|
|
|
extern HWDevice *filter_hw_device;
|
2013-11-03 00:06:36 +03:00
|
|
|
|
2021-11-10 15:51:48 +02:00
|
|
|
extern int want_sdp;
|
|
|
|
extern unsigned nb_output_dumped;
|
|
|
|
extern int main_return_code;
|
|
|
|
|
2012-08-01 19:23:12 +03:00
|
|
|
|
2012-08-09 01:26:38 +03:00
|
|
|
void term_init(void);
|
|
|
|
void term_exit(void);
|
2012-08-01 19:23:12 +03:00
|
|
|
|
2012-08-09 01:26:38 +03:00
|
|
|
void show_usage(void);
|
2012-08-01 19:23:12 +03:00
|
|
|
|
2014-08-04 14:32:11 +03:00
|
|
|
void remove_avoptions(AVDictionary **a, AVDictionary *b);
|
2012-08-01 19:23:12 +03:00
|
|
|
void assert_avoptions(AVDictionary *m);
|
|
|
|
|
|
|
|
int guess_input_channel_layout(InputStream *ist);
|
|
|
|
|
|
|
|
int configure_filtergraph(FilterGraph *fg);
|
2017-05-05 00:15:15 +02:00
|
|
|
void check_filter_outputs(void);
|
2016-05-22 17:57:59 +02:00
|
|
|
int filtergraph_is_simple(FilterGraph *fg);
|
2016-05-22 19:57:36 +02:00
|
|
|
int init_simple_filtergraph(InputStream *ist, OutputStream *ost);
|
2015-07-15 19:49:24 +02:00
|
|
|
int init_complex_filtergraph(FilterGraph *fg);
|
2012-08-01 19:23:12 +03:00
|
|
|
|
2019-02-23 01:48:08 +02:00
|
|
|
void sub2video_update(InputStream *ist, int64_t heartbeat_pts, AVSubtitle *sub);
|
2017-03-02 17:01:01 +02:00
|
|
|
|
2016-05-23 14:09:08 +02:00
|
|
|
int ifilter_parameters_from_frame(InputFilter *ifilter, const AVFrame *frame);
|
|
|
|
|
2012-12-20 04:38:02 +03:00
|
|
|
int ffmpeg_parse_options(int argc, char **argv);
|
2012-06-08 22:35:16 +03:00
|
|
|
|
2015-07-11 13:23:21 +02:00
|
|
|
int videotoolbox_init(AVCodecContext *s);
|
2015-10-13 14:11:35 +02:00
|
|
|
int qsv_init(AVCodecContext *s);
|
2013-11-03 21:21:00 +03:00
|
|
|
|
2017-03-05 01:57:30 +02:00
|
|
|
HWDevice *hw_device_get_by_name(const char *name);
|
|
|
|
int hw_device_init_from_string(const char *arg, HWDevice **dev);
|
|
|
|
void hw_device_free_all(void);
|
|
|
|
|
|
|
|
int hw_device_setup_for_decode(InputStream *ist);
|
|
|
|
int hw_device_setup_for_encode(OutputStream *ost);
|
2020-04-13 17:33:19 +02:00
|
|
|
int hw_device_setup_for_filter(FilterGraph *fg);
|
2017-03-05 01:57:30 +02:00
|
|
|
|
|
|
|
int hwaccel_decode_init(AVCodecContext *avctx);
|
|
|
|
|
2021-11-10 15:51:48 +02:00
|
|
|
/* open the muxer when all the streams are initialized */
|
|
|
|
int of_check_init(OutputFile *of);
|
2021-11-10 16:21:47 +02:00
|
|
|
int of_write_trailer(OutputFile *of);
|
2021-11-10 18:33:48 +02:00
|
|
|
void of_close(OutputFile **pof);
|
2021-11-10 15:51:48 +02:00
|
|
|
|
|
|
|
void of_write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost,
|
|
|
|
int unqueue);
|
|
|
|
|
2017-10-01 23:21:02 +02:00
|
|
|
#endif /* FFTOOLS_FFMPEG_H */
|