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"
|
|
|
|
|
2022-03-31 17:33:48 +02:00
|
|
|
#include <stdatomic.h>
|
2012-08-01 19:23:12 +03:00
|
|
|
#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"
|
2023-05-18 16:56:15 +02:00
|
|
|
#include "ffmpeg_sched.h"
|
2022-06-10 14:21:42 +02:00
|
|
|
#include "sync_queue.h"
|
2012-08-01 19:23:12 +03:00
|
|
|
|
|
|
|
#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"
|
|
|
|
|
2022-06-19 17:10:48 +02:00
|
|
|
// deprecated features
|
2023-03-28 11:48:50 +02:00
|
|
|
#define FFMPEG_OPT_QPHIST 1
|
2023-04-18 20:03:23 +02:00
|
|
|
#define FFMPEG_OPT_ADRIFT_THRESHOLD 1
|
2023-07-07 11:31:53 +02:00
|
|
|
#define FFMPEG_OPT_ENC_TIME_BASE_NUM 1
|
2023-09-14 17:07:29 +02:00
|
|
|
#define FFMPEG_OPT_TOP 1
|
2023-09-09 14:13:18 +02:00
|
|
|
#define FFMPEG_OPT_FORCE_KF_SOURCE_NO_DROP 1
|
2023-12-14 14:42:17 +02:00
|
|
|
#define FFMPEG_OPT_VSYNC_DROP 1
|
2023-12-18 11:50:44 +02:00
|
|
|
#define FFMPEG_OPT_VSYNC 1
|
2024-01-12 16:54:11 +02:00
|
|
|
#define FFMPEG_OPT_FILTER_SCRIPT 1
|
2022-06-19 17:10:48 +02:00
|
|
|
|
2023-07-18 16:37:52 +02:00
|
|
|
#define FFMPEG_ERROR_RATE_EXCEEDED FFERRTAG('E', 'R', 'E', 'D')
|
|
|
|
|
2021-12-04 15:53:58 +02:00
|
|
|
enum VideoSyncMethod {
|
|
|
|
VSYNC_AUTO = -1,
|
|
|
|
VSYNC_PASSTHROUGH,
|
|
|
|
VSYNC_CFR,
|
|
|
|
VSYNC_VFR,
|
|
|
|
VSYNC_VSCFR,
|
2023-12-14 14:42:17 +02:00
|
|
|
#if FFMPEG_OPT_VSYNC_DROP
|
2021-12-04 15:53:58 +02:00
|
|
|
VSYNC_DROP,
|
2023-12-14 14:42:17 +02:00
|
|
|
#endif
|
2021-12-04 15:53:58 +02:00
|
|
|
};
|
2012-08-09 01:26:38 +03:00
|
|
|
|
2023-07-07 11:31:53 +02:00
|
|
|
enum EncTimeBase {
|
|
|
|
ENC_TIME_BASE_DEMUX = -1,
|
|
|
|
ENC_TIME_BASE_FILTER = -2,
|
|
|
|
};
|
|
|
|
|
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
|
|
|
};
|
|
|
|
|
2023-06-08 20:36:33 +02:00
|
|
|
enum FrameOpaque {
|
2023-07-18 16:37:52 +02:00
|
|
|
FRAME_OPAQUE_SUB_HEARTBEAT = 1,
|
2023-06-08 20:36:33 +02:00
|
|
|
FRAME_OPAQUE_EOF,
|
|
|
|
FRAME_OPAQUE_SEND_COMMAND,
|
|
|
|
};
|
|
|
|
|
2023-07-18 16:37:52 +02:00
|
|
|
enum PacketOpaque {
|
|
|
|
PKT_OPAQUE_SUB_HEARTBEAT = 1,
|
|
|
|
PKT_OPAQUE_FIX_SUB_DURATION,
|
|
|
|
};
|
|
|
|
|
2023-11-24 20:08:15 +02:00
|
|
|
enum LatencyProbe {
|
|
|
|
LATENCY_PROBE_DEMUX,
|
|
|
|
LATENCY_PROBE_DEC_PRE,
|
|
|
|
LATENCY_PROBE_DEC_POST,
|
|
|
|
LATENCY_PROBE_FILTER_PRE,
|
|
|
|
LATENCY_PROBE_FILTER_POST,
|
|
|
|
LATENCY_PROBE_ENC_PRE,
|
|
|
|
LATENCY_PROBE_ENC_POST,
|
|
|
|
LATENCY_PROBE_NB,
|
|
|
|
};
|
|
|
|
|
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;
|
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;
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
2023-12-17 15:20:57 +02:00
|
|
|
SpecifierOptList codec_names;
|
|
|
|
SpecifierOptList audio_ch_layouts;
|
|
|
|
SpecifierOptList audio_channels;
|
|
|
|
SpecifierOptList audio_sample_rate;
|
|
|
|
SpecifierOptList frame_rates;
|
|
|
|
SpecifierOptList max_frame_rates;
|
|
|
|
SpecifierOptList frame_sizes;
|
|
|
|
SpecifierOptList frame_pix_fmts;
|
2012-08-01 19:23:12 +03:00
|
|
|
|
|
|
|
/* 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;
|
2023-05-02 13:35:34 +02:00
|
|
|
double readrate_initial_burst;
|
2013-06-15 10:59:40 +03:00
|
|
|
int accurate_seek;
|
2015-02-25 12:50:44 +02:00
|
|
|
int thread_queue_size;
|
2022-06-13 13:02:44 +02:00
|
|
|
int input_sync_ref;
|
2022-09-28 12:21:00 +02:00
|
|
|
int find_stream_info;
|
2012-08-01 19:23:12 +03:00
|
|
|
|
2023-12-17 15:20:57 +02:00
|
|
|
SpecifierOptList ts_scale;
|
|
|
|
SpecifierOptList dump_attachment;
|
|
|
|
SpecifierOptList hwaccels;
|
|
|
|
SpecifierOptList hwaccel_devices;
|
|
|
|
SpecifierOptList hwaccel_output_formats;
|
|
|
|
SpecifierOptList autorotate;
|
2012-08-01 19:23:12 +03:00
|
|
|
|
|
|
|
/* output options */
|
|
|
|
StreamMap *stream_maps;
|
|
|
|
int nb_stream_maps;
|
|
|
|
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;
|
2022-01-11 11:26:49 +02:00
|
|
|
int64_t limit_filesize;
|
2012-08-01 19:23:12 +03:00
|
|
|
float mux_preload;
|
|
|
|
float mux_max_delay;
|
2022-06-10 14:21:42 +02:00
|
|
|
float shortest_buf_duration;
|
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;
|
|
|
|
|
2023-07-13 17:36:57 +02:00
|
|
|
// keys are stream indices
|
|
|
|
AVDictionary *streamid;
|
2012-08-01 19:23:12 +03:00
|
|
|
|
2023-12-17 15:20:57 +02:00
|
|
|
SpecifierOptList metadata;
|
|
|
|
SpecifierOptList max_frames;
|
|
|
|
SpecifierOptList bitstream_filters;
|
|
|
|
SpecifierOptList codec_tags;
|
|
|
|
SpecifierOptList sample_fmts;
|
|
|
|
SpecifierOptList qscale;
|
|
|
|
SpecifierOptList forced_key_frames;
|
|
|
|
SpecifierOptList fps_mode;
|
|
|
|
SpecifierOptList force_fps;
|
|
|
|
SpecifierOptList frame_aspect_ratios;
|
|
|
|
SpecifierOptList display_rotations;
|
|
|
|
SpecifierOptList display_hflips;
|
|
|
|
SpecifierOptList display_vflips;
|
|
|
|
SpecifierOptList rc_overrides;
|
|
|
|
SpecifierOptList intra_matrices;
|
|
|
|
SpecifierOptList inter_matrices;
|
|
|
|
SpecifierOptList chroma_intra_matrices;
|
2023-09-14 17:07:29 +02:00
|
|
|
#if FFMPEG_OPT_TOP
|
2023-12-17 15:20:57 +02:00
|
|
|
SpecifierOptList top_field_first;
|
2023-09-14 17:07:29 +02:00
|
|
|
#endif
|
2023-12-17 15:20:57 +02:00
|
|
|
SpecifierOptList metadata_map;
|
|
|
|
SpecifierOptList presets;
|
|
|
|
SpecifierOptList copy_initial_nonkeyframes;
|
|
|
|
SpecifierOptList copy_prior_start;
|
|
|
|
SpecifierOptList filters;
|
2024-01-12 16:54:11 +02:00
|
|
|
#if FFMPEG_OPT_FILTER_SCRIPT
|
2023-12-17 15:20:57 +02:00
|
|
|
SpecifierOptList filter_scripts;
|
2024-01-12 16:54:11 +02:00
|
|
|
#endif
|
2023-12-17 15:20:57 +02:00
|
|
|
SpecifierOptList reinit_filters;
|
|
|
|
SpecifierOptList fix_sub_duration;
|
|
|
|
SpecifierOptList fix_sub_duration_heartbeat;
|
|
|
|
SpecifierOptList canvas_sizes;
|
|
|
|
SpecifierOptList pass;
|
|
|
|
SpecifierOptList passlogfiles;
|
|
|
|
SpecifierOptList max_muxing_queue_size;
|
|
|
|
SpecifierOptList muxing_queue_data_threshold;
|
|
|
|
SpecifierOptList guess_layout_max;
|
|
|
|
SpecifierOptList apad;
|
|
|
|
SpecifierOptList discard;
|
|
|
|
SpecifierOptList disposition;
|
|
|
|
SpecifierOptList program;
|
|
|
|
SpecifierOptList stream_groups;
|
|
|
|
SpecifierOptList time_bases;
|
|
|
|
SpecifierOptList enc_time_bases;
|
|
|
|
SpecifierOptList autoscale;
|
|
|
|
SpecifierOptList bits_per_raw_sample;
|
|
|
|
SpecifierOptList enc_stats_pre;
|
|
|
|
SpecifierOptList enc_stats_post;
|
|
|
|
SpecifierOptList mux_stats;
|
|
|
|
SpecifierOptList enc_stats_pre_fmt;
|
|
|
|
SpecifierOptList enc_stats_post_fmt;
|
|
|
|
SpecifierOptList mux_stats_fmt;
|
2012-08-01 19:23:12 +03:00
|
|
|
} OptionsContext;
|
|
|
|
|
2024-02-13 13:18:27 +02:00
|
|
|
enum IFilterFlags {
|
|
|
|
IFILTER_FLAG_AUTOROTATE = (1 << 0),
|
|
|
|
IFILTER_FLAG_REINIT = (1 << 1),
|
2024-02-13 13:18:27 +02:00
|
|
|
IFILTER_FLAG_CFR = (1 << 2),
|
2024-02-13 13:18:27 +02:00
|
|
|
};
|
|
|
|
|
2024-02-13 13:01:11 +02:00
|
|
|
typedef struct InputFilterOptions {
|
|
|
|
int64_t trim_start_us;
|
|
|
|
int64_t trim_end_us;
|
2024-02-13 13:18:27 +02:00
|
|
|
|
|
|
|
uint8_t *name;
|
2024-02-13 13:18:27 +02:00
|
|
|
|
2024-02-13 13:18:27 +02:00
|
|
|
/* When IFILTER_FLAG_CFR is set, the stream is guaranteed to be CFR with
|
|
|
|
* this framerate.
|
|
|
|
*
|
|
|
|
* Otherwise, this is an estimate that should not be relied upon to be
|
|
|
|
* accurate */
|
|
|
|
AVRational framerate;
|
|
|
|
|
2024-02-13 13:18:27 +02:00
|
|
|
int sub2video_width;
|
|
|
|
int sub2video_height;
|
2024-02-13 13:18:27 +02:00
|
|
|
|
|
|
|
// a combination of IFILTER_FLAG_*
|
|
|
|
unsigned flags;
|
2024-02-22 14:24:38 +02:00
|
|
|
|
|
|
|
AVFrame *fallback;
|
2024-02-13 13:01:11 +02:00
|
|
|
} InputFilterOptions;
|
|
|
|
|
2024-04-01 06:07:45 +02:00
|
|
|
typedef struct OutputFilterOptions {
|
|
|
|
// Codec used for encoding, may be NULL
|
|
|
|
const AVCodec *enc;
|
|
|
|
} OutputFilterOptions;
|
|
|
|
|
2012-08-01 19:23:12 +03:00
|
|
|
typedef struct InputFilter {
|
|
|
|
struct FilterGraph *graph;
|
|
|
|
uint8_t *name;
|
|
|
|
} InputFilter;
|
|
|
|
|
|
|
|
typedef struct OutputFilter {
|
|
|
|
struct OutputStream *ost;
|
|
|
|
struct FilterGraph *graph;
|
|
|
|
uint8_t *name;
|
|
|
|
|
2023-05-21 20:17:19 +02:00
|
|
|
/* for filters that are not yet bound to an output stream,
|
|
|
|
* this stores the output linklabel, if any */
|
|
|
|
uint8_t *linklabel;
|
|
|
|
|
2015-07-15 19:49:24 +02:00
|
|
|
enum AVMediaType type;
|
2016-05-23 14:09:08 +02:00
|
|
|
|
2023-07-18 16:37:52 +02:00
|
|
|
atomic_uint_least64_t nb_frames_dup;
|
|
|
|
atomic_uint_least64_t nb_frames_drop;
|
2012-08-01 19:23:12 +03:00
|
|
|
} OutputFilter;
|
|
|
|
|
|
|
|
typedef struct FilterGraph {
|
2023-06-08 20:58:16 +02:00
|
|
|
const AVClass *class;
|
2012-08-01 19:23:12 +03:00
|
|
|
int index;
|
|
|
|
|
|
|
|
InputFilter **inputs;
|
|
|
|
int nb_inputs;
|
|
|
|
OutputFilter **outputs;
|
|
|
|
int nb_outputs;
|
|
|
|
} FilterGraph;
|
|
|
|
|
2024-01-17 11:44:52 +02:00
|
|
|
enum DecoderFlags {
|
|
|
|
DECODER_FLAG_FIX_SUB_DURATION = (1 << 0),
|
2024-01-17 12:00:26 +02:00
|
|
|
// input timestamps are unreliable (guessed by demuxer)
|
|
|
|
DECODER_FLAG_TS_UNRELIABLE = (1 << 1),
|
2024-01-23 19:39:48 +02:00
|
|
|
// decoder should override timestamps by fixed framerate
|
|
|
|
// from DecoderOpts.framerate
|
|
|
|
DECODER_FLAG_FRAMERATE_FORCED = (1 << 2),
|
2024-01-23 19:42:20 +02:00
|
|
|
#if FFMPEG_OPT_TOP
|
|
|
|
DECODER_FLAG_TOP_FIELD_FIRST = (1 << 3),
|
|
|
|
#endif
|
2024-01-23 20:53:59 +02:00
|
|
|
DECODER_FLAG_SEND_END_TS = (1 << 4),
|
2024-03-22 18:45:34 +02:00
|
|
|
// force bitexact decoding
|
|
|
|
DECODER_FLAG_BITEXACT = (1 << 5),
|
2024-01-17 11:44:52 +02:00
|
|
|
};
|
|
|
|
|
2024-01-23 19:24:05 +02:00
|
|
|
typedef struct DecoderOpts {
|
2024-01-23 19:28:57 +02:00
|
|
|
int flags;
|
|
|
|
|
2024-01-23 19:42:20 +02:00
|
|
|
char *name;
|
2024-01-23 20:45:14 +02:00
|
|
|
void *log_parent;
|
2024-01-23 19:42:20 +02:00
|
|
|
|
2024-01-23 19:42:20 +02:00
|
|
|
const AVCodec *codec;
|
2024-01-23 19:42:20 +02:00
|
|
|
const AVCodecParameters *par;
|
2024-01-23 19:42:20 +02:00
|
|
|
|
2024-01-23 19:24:05 +02:00
|
|
|
/* hwaccel options */
|
|
|
|
enum HWAccelID hwaccel_id;
|
|
|
|
enum AVHWDeviceType hwaccel_device_type;
|
|
|
|
char *hwaccel_device;
|
|
|
|
enum AVPixelFormat hwaccel_output_format;
|
2024-01-23 19:39:48 +02:00
|
|
|
|
2024-01-23 19:42:20 +02:00
|
|
|
AVRational time_base;
|
|
|
|
|
2024-01-23 19:39:48 +02:00
|
|
|
// Either forced (when DECODER_FLAG_FRAMERATE_FORCED is set) or
|
|
|
|
// estimated (otherwise) video framerate.
|
|
|
|
AVRational framerate;
|
2024-01-23 19:24:05 +02:00
|
|
|
} DecoderOpts;
|
|
|
|
|
2024-01-10 13:10:58 +02:00
|
|
|
typedef struct Decoder {
|
2024-01-11 11:45:18 +02:00
|
|
|
const AVClass *class;
|
|
|
|
|
2024-02-19 11:27:44 +02:00
|
|
|
enum AVMediaType type;
|
|
|
|
|
2024-01-10 13:20:32 +02:00
|
|
|
const uint8_t *subtitle_header;
|
|
|
|
int subtitle_header_size;
|
2024-01-11 11:45:18 +02:00
|
|
|
|
|
|
|
// number of frames/samples retrieved from the decoder
|
|
|
|
uint64_t frames_decoded;
|
|
|
|
uint64_t samples_decoded;
|
|
|
|
uint64_t decode_errors;
|
2024-01-10 13:10:58 +02:00
|
|
|
} Decoder;
|
2023-05-18 05:39:39 +02:00
|
|
|
|
2012-08-01 19:23:12 +03:00
|
|
|
typedef struct InputStream {
|
2024-01-24 10:15:37 +02:00
|
|
|
const AVClass *class;
|
2023-02-11 08:59:36 +02:00
|
|
|
|
2023-12-13 19:39:02 +02:00
|
|
|
/* parent source */
|
2024-01-24 10:15:37 +02:00
|
|
|
struct InputFile *file;
|
2023-12-13 19:39:02 +02:00
|
|
|
|
2024-01-24 10:15:37 +02:00
|
|
|
int index;
|
2023-05-19 09:53:57 +02:00
|
|
|
|
2024-01-24 10:15:37 +02:00
|
|
|
AVStream *st;
|
|
|
|
int user_set_discard;
|
2014-09-01 05:13:49 +03:00
|
|
|
|
2022-08-13 17:03:39 +02:00
|
|
|
/**
|
|
|
|
* Codec parameters - to be used by the decoding/streamcopy code.
|
|
|
|
* st->codecpar should not be accessed, because it may be modified
|
|
|
|
* concurrently by the demuxing thread.
|
|
|
|
*/
|
2024-01-24 10:15:37 +02:00
|
|
|
AVCodecParameters *par;
|
|
|
|
Decoder *decoder;
|
|
|
|
const AVCodec *dec;
|
2012-08-01 19:23:12 +03:00
|
|
|
|
2024-01-24 10:15:37 +02:00
|
|
|
/* framerate forced with -r */
|
|
|
|
AVRational framerate;
|
2023-09-14 17:07:29 +02:00
|
|
|
#if FFMPEG_OPT_TOP
|
2024-01-24 10:15:37 +02:00
|
|
|
int top_field_first;
|
2023-09-14 17:07:29 +02:00
|
|
|
#endif
|
2012-08-01 19:23:12 +03:00
|
|
|
|
2024-01-24 10:15:37 +02:00
|
|
|
int fix_sub_duration;
|
2012-08-09 12:44:17 +03:00
|
|
|
|
2012-08-01 19:23:12 +03:00
|
|
|
/* decoded data from this stream goes into all those filters
|
|
|
|
* currently video and audio only */
|
2024-01-24 10:15:37 +02:00
|
|
|
InputFilter **filters;
|
|
|
|
int nb_filters;
|
2012-10-17 00:50:06 +03:00
|
|
|
|
2023-03-31 12:47:03 +02:00
|
|
|
/*
|
|
|
|
* Output targets that do not go through lavfi, i.e. subtitles or
|
|
|
|
* streamcopy. Those two cases are distinguished by the OutputStream
|
|
|
|
* having an encoder or not.
|
|
|
|
*/
|
|
|
|
struct OutputStream **outputs;
|
|
|
|
int nb_outputs;
|
2012-08-01 19:23:12 +03:00
|
|
|
} InputStream;
|
|
|
|
|
|
|
|
typedef struct InputFile {
|
2024-01-24 10:15:37 +02:00
|
|
|
const AVClass *class;
|
2023-01-29 13:35:47 +02:00
|
|
|
|
2024-01-24 10:15:37 +02:00
|
|
|
int index;
|
2022-03-21 18:21:46 +02:00
|
|
|
|
2012-08-01 19:23:12 +03:00
|
|
|
AVFormatContext *ctx;
|
2024-01-24 10:15:37 +02:00
|
|
|
int64_t input_ts_offset;
|
|
|
|
int input_sync_ref;
|
2022-10-21 15:59:25 +02:00
|
|
|
/**
|
|
|
|
* Effective format start time based on enabled streams.
|
|
|
|
*/
|
2024-01-24 10:15:37 +02:00
|
|
|
int64_t start_time_effective;
|
|
|
|
int64_t ts_offset;
|
|
|
|
/* user-specified start time in AV_TIME_BASE or AV_NOPTS_VALUE */
|
|
|
|
int64_t start_time;
|
2022-11-17 10:49:27 +02:00
|
|
|
|
|
|
|
/* streams that ffmpeg is aware of;
|
|
|
|
* there may be extra streams in ctx that are not mapped to an InputStream
|
|
|
|
* if new streams appear dynamically during demuxing */
|
2024-01-24 10:15:37 +02:00
|
|
|
InputStream **streams;
|
|
|
|
int nb_streams;
|
2012-08-01 19:23:12 +03:00
|
|
|
} 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
|
|
|
|
2022-11-25 15:00:48 +02:00
|
|
|
enum EncStatsType {
|
|
|
|
ENC_STATS_LITERAL = 0,
|
|
|
|
ENC_STATS_FILE_IDX,
|
|
|
|
ENC_STATS_STREAM_IDX,
|
|
|
|
ENC_STATS_FRAME_NUM,
|
2023-01-27 13:19:16 +02:00
|
|
|
ENC_STATS_FRAME_NUM_IN,
|
2022-11-25 15:00:48 +02:00
|
|
|
ENC_STATS_TIMEBASE,
|
2023-01-27 13:19:16 +02:00
|
|
|
ENC_STATS_TIMEBASE_IN,
|
2022-11-25 15:00:48 +02:00
|
|
|
ENC_STATS_PTS,
|
|
|
|
ENC_STATS_PTS_TIME,
|
2023-01-27 13:19:16 +02:00
|
|
|
ENC_STATS_PTS_IN,
|
|
|
|
ENC_STATS_PTS_TIME_IN,
|
2022-11-25 15:00:48 +02:00
|
|
|
ENC_STATS_DTS,
|
|
|
|
ENC_STATS_DTS_TIME,
|
|
|
|
ENC_STATS_SAMPLE_NUM,
|
|
|
|
ENC_STATS_NB_SAMPLES,
|
|
|
|
ENC_STATS_PKT_SIZE,
|
|
|
|
ENC_STATS_BITRATE,
|
|
|
|
ENC_STATS_AVG_BITRATE,
|
2023-12-14 20:26:56 +02:00
|
|
|
ENC_STATS_KEYFRAME,
|
2022-11-25 15:00:48 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
typedef struct EncStatsComponent {
|
|
|
|
enum EncStatsType type;
|
|
|
|
|
|
|
|
uint8_t *str;
|
|
|
|
size_t str_len;
|
|
|
|
} EncStatsComponent;
|
|
|
|
|
|
|
|
typedef struct EncStats {
|
|
|
|
EncStatsComponent *components;
|
|
|
|
int nb_components;
|
|
|
|
|
|
|
|
AVIOContext *io;
|
2023-12-14 21:15:02 +02:00
|
|
|
|
|
|
|
pthread_mutex_t lock;
|
|
|
|
int lock_initialized;
|
2022-11-25 15:00:48 +02:00
|
|
|
} EncStats;
|
|
|
|
|
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 ;
|
|
|
|
|
2022-11-17 15:35:36 +02:00
|
|
|
enum {
|
|
|
|
KF_FORCE_SOURCE = 1,
|
2023-09-09 14:13:18 +02:00
|
|
|
#if FFMPEG_OPT_FORCE_KF_SOURCE_NO_DROP
|
2022-11-17 15:35:36 +02:00
|
|
|
KF_FORCE_SOURCE_NO_DROP = 2,
|
2023-09-09 14:13:18 +02:00
|
|
|
#endif
|
2022-11-17 15:35:36 +02:00
|
|
|
};
|
|
|
|
|
2022-11-17 13:42:01 +02:00
|
|
|
typedef struct KeyframeForceCtx {
|
2022-11-17 15:35:36 +02:00
|
|
|
int type;
|
2022-11-17 13:42:01 +02:00
|
|
|
|
|
|
|
int64_t ref_pts;
|
|
|
|
|
2022-11-17 13:55:47 +02:00
|
|
|
// timestamps of the forced keyframes, in AV_TIME_BASE_Q
|
2022-11-17 13:42:01 +02:00
|
|
|
int64_t *pts;
|
|
|
|
int nb_pts;
|
|
|
|
int index;
|
|
|
|
|
|
|
|
AVExpr *pexpr;
|
|
|
|
double expr_const_values[FKF_NB];
|
|
|
|
|
|
|
|
int dropped_keyframe;
|
|
|
|
} KeyframeForceCtx;
|
|
|
|
|
2023-03-25 20:46:28 +02:00
|
|
|
typedef struct Encoder Encoder;
|
|
|
|
|
2012-08-01 19:23:12 +03:00
|
|
|
typedef struct OutputStream {
|
2023-01-28 11:06:20 +02:00
|
|
|
const AVClass *class;
|
|
|
|
|
2023-04-11 10:15:55 +02:00
|
|
|
enum AVMediaType type;
|
|
|
|
|
2023-12-13 19:39:02 +02:00
|
|
|
/* parent muxer */
|
|
|
|
struct OutputFile *file;
|
|
|
|
|
2012-08-01 19:23:12 +03:00
|
|
|
int index; /* stream index in the output file */
|
2022-11-16 16:36:24 +02:00
|
|
|
|
2023-04-13 14:22:28 +02:00
|
|
|
/**
|
|
|
|
* Codec parameters for packets submitted to the muxer (i.e. before
|
|
|
|
* bitstream filtering, if any).
|
|
|
|
*/
|
|
|
|
AVCodecParameters *par_in;
|
|
|
|
|
2022-11-16 16:36:24 +02:00
|
|
|
/* input stream that is the source for this output stream;
|
|
|
|
* may be NULL for streams with no well-defined source, e.g.
|
|
|
|
* attachments or outputs from complex filtergraphs */
|
|
|
|
InputStream *ist;
|
|
|
|
|
2012-08-01 19:23:12 +03:00
|
|
|
AVStream *st; /* stream in the output file */
|
2022-08-10 10:44:30 +02:00
|
|
|
|
2017-05-03 10:50:15 +02:00
|
|
|
AVRational enc_timebase;
|
2016-09-21 15:39:16 +02:00
|
|
|
|
2023-03-25 20:46:28 +02:00
|
|
|
Encoder *enc;
|
2014-04-05 09:48:24 +03:00
|
|
|
AVCodecContext *enc_ctx;
|
2023-05-28 16:51:57 +02:00
|
|
|
|
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;
|
2023-09-14 17:07:29 +02:00
|
|
|
#if FFMPEG_OPT_TOP
|
2012-08-01 19:23:12 +03:00
|
|
|
int top_field_first;
|
2022-10-19 10:54:29 +02:00
|
|
|
#endif
|
2020-06-08 10:58:05 +02:00
|
|
|
int autoscale;
|
2021-12-11 16:37:41 +02:00
|
|
|
int bitexact;
|
2021-11-23 11:18:01 +02:00
|
|
|
int bits_per_raw_sample;
|
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
|
|
|
|
2022-11-17 13:42:01 +02:00
|
|
|
KeyframeForceCtx kf;
|
2012-08-01 19:23:12 +03:00
|
|
|
|
2012-08-19 10:15:48 +03:00
|
|
|
char *logfile_prefix;
|
2012-08-01 19:23:12 +03:00
|
|
|
FILE *logfile;
|
|
|
|
|
|
|
|
OutputFilter *filter;
|
|
|
|
|
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;
|
2016-05-23 09:19:25 +02:00
|
|
|
|
2024-02-18 16:19:49 +02:00
|
|
|
char *attachment_filename;
|
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 */
|
2014-03-17 12:58:05 +03:00
|
|
|
// number of packets send to the muxer
|
2022-03-31 17:33:48 +02:00
|
|
|
atomic_uint_least64_t packets_written;
|
2014-03-17 12:58:05 +03:00
|
|
|
// number of frames/samples sent to the encoder
|
|
|
|
uint64_t frames_encoded;
|
|
|
|
uint64_t samples_encoded;
|
2015-07-15 19:41:21 +02:00
|
|
|
|
|
|
|
/* packet quality factor */
|
2023-07-18 16:37:52 +02:00
|
|
|
atomic_int quality;
|
2015-07-28 01:28:34 +02:00
|
|
|
|
2022-11-25 15:00:48 +02:00
|
|
|
EncStats enc_stats_pre;
|
|
|
|
EncStats enc_stats_post;
|
2022-07-22 12:57:54 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* bool on whether this stream should be utilized for splitting
|
|
|
|
* subtitles utilizing fix_sub_duration at random access points.
|
|
|
|
*/
|
|
|
|
unsigned int fix_sub_duration_heartbeat;
|
2012-08-01 19:23:12 +03:00
|
|
|
} OutputStream;
|
|
|
|
|
|
|
|
typedef struct OutputFile {
|
2023-01-28 11:06:20 +02:00
|
|
|
const AVClass *class;
|
|
|
|
|
2021-12-11 14:22:36 +02:00
|
|
|
int index;
|
|
|
|
|
2021-11-11 11:35:15 +02:00
|
|
|
const AVOutputFormat *format;
|
2022-03-30 10:50:37 +02:00
|
|
|
const char *url;
|
2021-11-11 11:35:15 +02:00
|
|
|
|
2022-10-14 10:57:19 +02:00
|
|
|
OutputStream **streams;
|
|
|
|
int nb_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
|
2012-08-11 12:50:32 +03:00
|
|
|
|
|
|
|
int shortest;
|
2021-12-11 16:37:41 +02:00
|
|
|
int bitexact;
|
2012-08-01 19:23:12 +03:00
|
|
|
} OutputFile;
|
|
|
|
|
2023-03-25 12:49:54 +02:00
|
|
|
// optionally attached as opaque_ref to decoded AVFrames
|
|
|
|
typedef struct FrameData {
|
2023-11-24 10:49:37 +02:00
|
|
|
// demuxer-estimated dts in AV_TIME_BASE_Q,
|
|
|
|
// to be used when real dts is missing
|
|
|
|
int64_t dts_est;
|
|
|
|
|
2023-07-07 11:02:15 +02:00
|
|
|
// properties that come from the decoder
|
|
|
|
struct {
|
|
|
|
uint64_t frame_num;
|
|
|
|
|
|
|
|
int64_t pts;
|
|
|
|
AVRational tb;
|
|
|
|
} dec;
|
2023-05-27 12:32:38 +02:00
|
|
|
|
|
|
|
AVRational frame_rate_filter;
|
2023-05-27 17:38:36 +02:00
|
|
|
|
|
|
|
int bits_per_raw_sample;
|
2023-11-24 20:08:15 +02:00
|
|
|
|
|
|
|
int64_t wallclock[LATENCY_PROBE_NB];
|
2024-02-19 11:27:44 +02:00
|
|
|
|
|
|
|
AVCodecParameters *par_enc;
|
2023-03-25 12:49:54 +02:00
|
|
|
} FrameData;
|
|
|
|
|
2012-08-01 19:23:12 +03:00
|
|
|
extern InputFile **input_files;
|
|
|
|
extern int nb_input_files;
|
|
|
|
|
|
|
|
extern OutputFile **output_files;
|
|
|
|
extern int nb_output_files;
|
|
|
|
|
|
|
|
extern FilterGraph **filtergraphs;
|
|
|
|
extern int nb_filtergraphs;
|
|
|
|
|
2024-02-19 11:27:44 +02:00
|
|
|
// standalone decoders (not tied to demuxed streams)
|
|
|
|
extern Decoder **decoders;
|
|
|
|
extern int nb_decoders;
|
|
|
|
|
2012-08-01 19:23:12 +03:00
|
|
|
extern char *vstats_filename;
|
|
|
|
|
|
|
|
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
|
|
|
|
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_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-09 01:26:38 +03:00
|
|
|
extern int stdin_interaction;
|
|
|
|
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-03-05 01:57:38 +02:00
|
|
|
extern HWDevice *filter_hw_device;
|
2013-11-03 00:06:36 +03:00
|
|
|
|
2023-07-18 16:37:52 +02:00
|
|
|
extern atomic_uint nb_output_dumped;
|
2021-11-10 15:51:48 +02:00
|
|
|
|
2022-10-13 12:24:43 +02:00
|
|
|
extern int ignore_unknown_streams;
|
|
|
|
extern int copy_unknown_streams;
|
|
|
|
|
2022-10-17 10:49:42 +02:00
|
|
|
extern int recast_media;
|
|
|
|
|
2023-03-25 12:49:54 +02:00
|
|
|
extern FILE *vstats_file;
|
|
|
|
|
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);
|
2023-07-14 18:18:57 +02:00
|
|
|
int check_avoptions(AVDictionary *m);
|
2012-08-01 19:23:12 +03:00
|
|
|
|
2023-07-12 13:09:14 +02:00
|
|
|
int assert_file_overwrite(const char *filename);
|
2022-11-14 12:18:26 +02:00
|
|
|
AVDictionary *strip_specifiers(const AVDictionary *dict);
|
2023-07-14 13:47:23 +02:00
|
|
|
int find_codec(void *logctx, const char *name,
|
|
|
|
enum AVMediaType type, int encoder, const AVCodec **codec);
|
2022-10-13 12:24:43 +02:00
|
|
|
int parse_and_set_vsync(const char *arg, int *vsync_var, int file_idx, int st_idx, int is_global);
|
|
|
|
|
2023-05-24 12:39:47 +02:00
|
|
|
int filtergraph_is_simple(const FilterGraph *fg);
|
2023-05-21 19:16:39 +02:00
|
|
|
int init_simple_filtergraph(InputStream *ist, OutputStream *ost,
|
2023-05-18 16:56:15 +02:00
|
|
|
char *graph_desc,
|
2024-04-01 06:07:45 +02:00
|
|
|
Scheduler *sch, unsigned sch_idx_enc,
|
|
|
|
const OutputFilterOptions *opts);
|
2024-02-21 16:28:01 +02:00
|
|
|
int fg_finalise_bindings(FilterGraph *fg);
|
2012-08-01 19:23:12 +03:00
|
|
|
|
2023-05-27 12:25:51 +02:00
|
|
|
/**
|
|
|
|
* Get our axiliary frame data attached to the frame, allocating it
|
|
|
|
* if needed.
|
|
|
|
*/
|
|
|
|
FrameData *frame_data(AVFrame *frame);
|
|
|
|
|
2023-11-13 10:35:44 +02:00
|
|
|
const FrameData *frame_data_c(AVFrame *frame);
|
|
|
|
|
2023-11-24 10:49:37 +02:00
|
|
|
FrameData *packet_data (AVPacket *pkt);
|
|
|
|
const FrameData *packet_data_c(AVPacket *pkt);
|
|
|
|
|
2023-05-18 16:56:15 +02:00
|
|
|
int ofilter_bind_ost(OutputFilter *ofilter, OutputStream *ost,
|
2024-04-01 06:07:45 +02:00
|
|
|
unsigned sched_idx_enc,
|
|
|
|
const OutputFilterOptions *opts);
|
2023-05-21 22:33:13 +02:00
|
|
|
|
2023-04-18 14:11:03 +02:00
|
|
|
/**
|
|
|
|
* Create a new filtergraph in the global filtergraph list.
|
|
|
|
*
|
|
|
|
* @param graph_desc Graph description; an av_malloc()ed string, filtergraph
|
|
|
|
* takes ownership of it.
|
|
|
|
*/
|
2023-05-18 16:56:15 +02:00
|
|
|
int fg_create(FilterGraph **pfg, char *graph_desc, Scheduler *sch);
|
2023-04-18 14:11:03 +02:00
|
|
|
|
2023-04-18 19:41:48 +02:00
|
|
|
void fg_free(FilterGraph **pfg);
|
|
|
|
|
2023-07-16 12:38:24 +02:00
|
|
|
void fg_send_command(FilterGraph *fg, double time, const char *target,
|
|
|
|
const char *command, const char *arg, int all_filters);
|
|
|
|
|
2023-05-18 16:56:15 +02:00
|
|
|
int ffmpeg_parse_options(int argc, char **argv, Scheduler *sch);
|
2012-06-08 22:35:16 +03:00
|
|
|
|
2023-02-06 14:14:53 +02:00
|
|
|
void enc_stats_write(OutputStream *ost, EncStats *es,
|
|
|
|
const AVFrame *frame, const AVPacket *pkt,
|
|
|
|
uint64_t frame_num);
|
|
|
|
|
2017-03-05 01:57:30 +02:00
|
|
|
HWDevice *hw_device_get_by_name(const char *name);
|
2023-05-17 17:04:28 +02:00
|
|
|
HWDevice *hw_device_get_by_type(enum AVHWDeviceType type);
|
2017-03-05 01:57:30 +02:00
|
|
|
int hw_device_init_from_string(const char *arg, HWDevice **dev);
|
2023-05-17 17:04:28 +02:00
|
|
|
int hw_device_init_from_type(enum AVHWDeviceType type,
|
|
|
|
const char *device,
|
|
|
|
HWDevice **dev_out);
|
2017-03-05 01:57:30 +02:00
|
|
|
void hw_device_free_all(void);
|
|
|
|
|
2023-03-15 20:09:11 +02:00
|
|
|
/**
|
|
|
|
* Get a hardware device to be used with this filtergraph.
|
|
|
|
* The returned reference is owned by the callee, the caller
|
|
|
|
* must ref it explicitly for long-term use.
|
|
|
|
*/
|
|
|
|
AVBufferRef *hw_device_for_filter(void);
|
2017-03-05 01:57:30 +02:00
|
|
|
|
2024-02-19 11:27:44 +02:00
|
|
|
/**
|
|
|
|
* Create a standalone decoder.
|
|
|
|
*/
|
|
|
|
int dec_create(const OptionsContext *o, const char *arg, Scheduler *sch);
|
|
|
|
|
2024-01-11 11:45:18 +02:00
|
|
|
/**
|
|
|
|
* @param dec_opts Dictionary filled with decoder options. Its ownership
|
|
|
|
* is transferred to the decoder.
|
2024-02-22 14:24:38 +02:00
|
|
|
* @param param_out If non-NULL, media properties after opening the decoder
|
|
|
|
* are written here.
|
2024-01-23 20:53:59 +02:00
|
|
|
*
|
|
|
|
* @retval ">=0" non-negative scheduler index on success
|
|
|
|
* @retval "<0" an error code on failure
|
2024-01-11 11:45:18 +02:00
|
|
|
*/
|
2024-02-19 13:11:33 +02:00
|
|
|
int dec_init(Decoder **pdec, Scheduler *sch,
|
2024-02-22 14:24:38 +02:00
|
|
|
AVDictionary **dec_opts, const DecoderOpts *o,
|
|
|
|
AVFrame *param_out);
|
2023-05-18 05:39:39 +02:00
|
|
|
void dec_free(Decoder **pdec);
|
2023-04-11 13:21:56 +02:00
|
|
|
|
2024-02-19 11:27:44 +02:00
|
|
|
/*
|
|
|
|
* Called by filters to connect decoder's output to given filtergraph input.
|
|
|
|
*
|
|
|
|
* @param opts filtergraph input options, to be filled by this function
|
|
|
|
*/
|
|
|
|
int dec_filter_add(Decoder *dec, InputFilter *ifilter, InputFilterOptions *opts);
|
|
|
|
|
2023-05-18 16:56:15 +02:00
|
|
|
int enc_alloc(Encoder **penc, const AVCodec *codec,
|
|
|
|
Scheduler *sch, unsigned sch_idx);
|
2023-03-25 20:46:28 +02:00
|
|
|
void enc_free(Encoder **penc);
|
|
|
|
|
2023-07-18 16:37:52 +02:00
|
|
|
int enc_open(void *opaque, const AVFrame *frame);
|
2023-03-25 05:36:28 +02:00
|
|
|
|
2024-02-19 11:27:44 +02:00
|
|
|
int enc_loopback(Encoder *enc);
|
|
|
|
|
2022-10-11 13:38:17 +02:00
|
|
|
/*
|
|
|
|
* Initialize muxing state for the given stream, should be called
|
|
|
|
* after the codec/streamcopy setup has been done.
|
|
|
|
*
|
|
|
|
* Open the muxer once all the streams have been initialized.
|
|
|
|
*/
|
|
|
|
int of_stream_init(OutputFile *of, OutputStream *ost);
|
2021-11-10 16:21:47 +02:00
|
|
|
int of_write_trailer(OutputFile *of);
|
2023-05-18 16:56:15 +02:00
|
|
|
int of_open(const OptionsContext *o, const char *filename, Scheduler *sch);
|
2023-07-08 10:22:13 +02:00
|
|
|
void of_free(OutputFile **pof);
|
2021-11-10 15:51:48 +02:00
|
|
|
|
2022-11-25 15:00:48 +02:00
|
|
|
void of_enc_stats_close(void);
|
|
|
|
|
2021-12-11 15:44:38 +02:00
|
|
|
int64_t of_filesize(OutputFile *of);
|
2021-11-10 15:51:48 +02:00
|
|
|
|
2023-05-18 16:56:15 +02:00
|
|
|
int ifile_open(const OptionsContext *o, const char *filename, Scheduler *sch);
|
2022-10-17 11:37:45 +02:00
|
|
|
void ifile_close(InputFile **f);
|
2022-10-17 10:49:42 +02:00
|
|
|
|
2023-05-11 10:51:13 +02:00
|
|
|
int ist_output_add(InputStream *ist, OutputStream *ost);
|
2024-02-13 13:01:11 +02:00
|
|
|
int ist_filter_add(InputStream *ist, InputFilter *ifilter, int is_simple,
|
|
|
|
InputFilterOptions *opts);
|
2023-03-31 12:47:03 +02:00
|
|
|
|
2023-05-11 10:40:58 +02:00
|
|
|
/**
|
|
|
|
* Find an unused input stream of given type.
|
|
|
|
*/
|
|
|
|
InputStream *ist_find_unused(enum AVMediaType type);
|
|
|
|
|
2022-11-17 10:49:27 +02:00
|
|
|
/* iterate over all input streams in all input files;
|
|
|
|
* pass NULL to start iteration */
|
|
|
|
InputStream *ist_iter(InputStream *prev);
|
|
|
|
|
2023-03-25 12:49:54 +02:00
|
|
|
/* iterate over all output streams in all output files;
|
|
|
|
* pass NULL to start iteration */
|
|
|
|
OutputStream *ost_iter(OutputStream *prev);
|
|
|
|
|
|
|
|
void update_benchmark(const char *fmt, ...);
|
|
|
|
|
2022-10-13 12:24:43 +02:00
|
|
|
#define SPECIFIER_OPT_FMT_str "%s"
|
|
|
|
#define SPECIFIER_OPT_FMT_i "%i"
|
|
|
|
#define SPECIFIER_OPT_FMT_i64 "%"PRId64
|
|
|
|
#define SPECIFIER_OPT_FMT_ui64 "%"PRIu64
|
|
|
|
#define SPECIFIER_OPT_FMT_f "%f"
|
|
|
|
#define SPECIFIER_OPT_FMT_dbl "%lf"
|
|
|
|
|
2023-12-17 19:10:17 +02:00
|
|
|
#define WARN_MULTIPLE_OPT_USAGE(optname, type, idx, st)\
|
2022-10-13 12:24:43 +02:00
|
|
|
{\
|
|
|
|
char namestr[128] = "";\
|
2023-12-17 19:10:17 +02:00
|
|
|
const SpecifierOpt *so = &o->optname.opt[idx];\
|
2022-10-13 12:24:43 +02:00
|
|
|
const char *spec = so->specifier && so->specifier[0] ? so->specifier : "";\
|
2023-12-17 19:10:17 +02:00
|
|
|
snprintf(namestr, sizeof(namestr), "-%s", o->optname.opt_canon->name);\
|
|
|
|
if (o->optname.opt_canon->flags & OPT_HAS_ALT) {\
|
|
|
|
const char * const *names_alt = o->optname.opt_canon->u1.names_alt;\
|
|
|
|
for (int _i = 0; names_alt[_i]; _i++)\
|
|
|
|
av_strlcatf(namestr, sizeof(namestr), "/-%s", names_alt[_i]);\
|
|
|
|
}\
|
2022-10-13 12:24:43 +02:00
|
|
|
av_log(NULL, AV_LOG_WARNING, "Multiple %s options specified for stream %d, only the last option '-%s%s%s "SPECIFIER_OPT_FMT_##type"' will be used.\n",\
|
2023-12-17 19:10:17 +02:00
|
|
|
namestr, st->index, o->optname.opt_canon->name, spec[0] ? ":" : "", spec, so->u.type);\
|
2022-10-13 12:24:43 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
#define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
|
|
|
|
{\
|
2023-12-17 19:10:17 +02:00
|
|
|
int _ret, _matches = 0, _match_idx;\
|
2023-12-17 15:20:57 +02:00
|
|
|
for (int _i = 0; _i < o->name.nb_opt; _i++) {\
|
|
|
|
char *spec = o->name.opt[_i].specifier;\
|
2022-11-17 11:38:12 +02:00
|
|
|
if ((_ret = check_stream_specifier(fmtctx, st, spec)) > 0) {\
|
2023-12-17 15:20:57 +02:00
|
|
|
outvar = o->name.opt[_i].u.type;\
|
2023-12-17 19:10:17 +02:00
|
|
|
_match_idx = _i;\
|
2022-11-17 11:38:12 +02:00
|
|
|
_matches++;\
|
|
|
|
} else if (_ret < 0)\
|
2023-07-14 18:20:03 +02:00
|
|
|
return _ret;\
|
2022-10-13 12:24:43 +02:00
|
|
|
}\
|
2023-12-17 19:10:17 +02:00
|
|
|
if (_matches > 1 && o->name.opt_canon)\
|
|
|
|
WARN_MULTIPLE_OPT_USAGE(name, type, _match_idx, st);\
|
2022-10-13 12:24:43 +02:00
|
|
|
}
|
|
|
|
|
2023-12-17 15:42:38 +02:00
|
|
|
const char *opt_match_per_type_str(const SpecifierOptList *sol,
|
|
|
|
char mediatype);
|
2022-10-13 12:24:43 +02:00
|
|
|
|
2024-02-22 17:02:21 +02:00
|
|
|
int muxer_thread(void *arg);
|
|
|
|
int encoder_thread(void *arg);
|
2023-05-18 16:56:15 +02:00
|
|
|
|
2017-10-01 23:21:02 +02:00
|
|
|
#endif /* FFTOOLS_FFMPEG_H */
|