FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/fftools/ffmpeg_opt.c
Date: 2023-03-31 03:41:15
Exec Total Coverage
Lines: 307 717 42.8%
Functions: 29 52 55.8%
Branches: 142 392 36.2%

Line Branch Exec Source
1 /*
2 * ffmpeg option parsing
3 *
4 * This file is part of FFmpeg.
5 *
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 #include "config.h"
22
23 #include <stdint.h>
24
25 #if HAVE_SYS_RESOURCE_H
26 #include <sys/time.h>
27 #include <sys/resource.h>
28 #endif
29
30 #include "ffmpeg.h"
31 #include "cmdutils.h"
32 #include "opt_common.h"
33 #include "sync_queue.h"
34
35 #include "libavformat/avformat.h"
36
37 #include "libavcodec/avcodec.h"
38 #include "libavcodec/bsf.h"
39
40 #include "libavfilter/avfilter.h"
41
42 #include "libavutil/avassert.h"
43 #include "libavutil/avstring.h"
44 #include "libavutil/avutil.h"
45 #include "libavutil/bprint.h"
46 #include "libavutil/channel_layout.h"
47 #include "libavutil/display.h"
48 #include "libavutil/intreadwrite.h"
49 #include "libavutil/fifo.h"
50 #include "libavutil/mathematics.h"
51 #include "libavutil/opt.h"
52 #include "libavutil/parseutils.h"
53 #include "libavutil/pixdesc.h"
54 #include "libavutil/pixfmt.h"
55
56 const char *const opt_name_codec_names[] = {"c", "codec", "acodec", "vcodec", "scodec", "dcodec", NULL};
57 const char *const opt_name_frame_rates[] = {"r", NULL};
58 const char *const opt_name_codec_tags[] = {"tag", "atag", "vtag", "stag", NULL};
59 const char *const opt_name_top_field_first[] = {"top", NULL};
60
61 HWDevice *filter_hw_device;
62
63 char *vstats_filename;
64 char *sdp_filename;
65
66 float audio_drift_threshold = 0.1;
67 float dts_delta_threshold = 10;
68 float dts_error_threshold = 3600*30;
69
70 enum VideoSyncMethod video_sync_method = VSYNC_AUTO;
71 float frame_drop_threshold = 0;
72 int do_benchmark = 0;
73 int do_benchmark_all = 0;
74 int do_hex_dump = 0;
75 int do_pkt_dump = 0;
76 int copy_ts = 0;
77 int start_at_zero = 0;
78 int copy_tb = -1;
79 int debug_ts = 0;
80 int exit_on_error = 0;
81 int abort_on_flags = 0;
82 int print_stats = -1;
83 int qp_hist = 0;
84 int stdin_interaction = 1;
85 float max_error_rate = 2.0/3;
86 char *filter_nbthreads;
87 int filter_complex_nbthreads = 0;
88 int vstats_version = 2;
89 int auto_conversion_filters = 1;
90 int64_t stats_period = 500000;
91
92
93 static int file_overwrite = 0;
94 static int no_file_overwrite = 0;
95 #if FFMPEG_OPT_PSNR
96 int do_psnr = 0;
97 #endif
98 int ignore_unknown_streams = 0;
99 int copy_unknown_streams = 0;
100 int recast_media = 0;
101
102 12990 static void uninit_options(OptionsContext *o)
103 {
104 12990 const OptionDef *po = options;
105 int i;
106
107 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
108
2/2
✓ Branch 0 taken 2481090 times.
✓ Branch 1 taken 12990 times.
2494080 while (po->name) {
109 2481090 void *dst = (uint8_t*)o + po->u.off;
110
111
2/2
✓ Branch 0 taken 818370 times.
✓ Branch 1 taken 1662720 times.
2481090 if (po->flags & OPT_SPEC) {
112 818370 SpecifierOpt **so = dst;
113 818370 int i, *count = (int*)(so + 1);
114
2/2
✓ Branch 0 taken 26322 times.
✓ Branch 1 taken 818370 times.
844692 for (i = 0; i < *count; i++) {
115 26322 av_freep(&(*so)[i].specifier);
116
2/2
✓ Branch 0 taken 21234 times.
✓ Branch 1 taken 5088 times.
26322 if (po->flags & OPT_STRING)
117 21234 av_freep(&(*so)[i].u.str);
118 }
119 818370 av_freep(so);
120 818370 *count = 0;
121
4/4
✓ Branch 0 taken 324750 times.
✓ Branch 1 taken 1337970 times.
✓ Branch 2 taken 12990 times.
✓ Branch 3 taken 311760 times.
1662720 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
122 12990 av_freep(dst);
123 2481090 po++;
124 }
125
126
2/2
✓ Branch 0 taken 236 times.
✓ Branch 1 taken 12990 times.
13226 for (i = 0; i < o->nb_stream_maps; i++)
127 236 av_freep(&o->stream_maps[i].linklabel);
128 12990 av_freep(&o->stream_maps);
129 #if FFMPEG_OPT_MAP_CHANNEL
130 12990 av_freep(&o->audio_channel_maps);
131 #endif
132 12990 av_freep(&o->streamid_map);
133 12990 av_freep(&o->attachments);
134 12990 }
135
136 12990 static void init_options(OptionsContext *o)
137 {
138 12990 memset(o, 0, sizeof(*o));
139
140 12990 o->stop_time = INT64_MAX;
141 12990 o->mux_max_delay = 0.7;
142 12990 o->start_time = AV_NOPTS_VALUE;
143 12990 o->start_time_eof = AV_NOPTS_VALUE;
144 12990 o->recording_time = INT64_MAX;
145 12990 o->limit_filesize = INT64_MAX;
146 12990 o->chapters_input_file = INT_MAX;
147 12990 o->accurate_seek = 1;
148 12990 o->thread_queue_size = -1;
149 12990 o->input_sync_ref = -1;
150 12990 o->find_stream_info = 1;
151 12990 o->shortest_buf_duration = 10.f;
152 12990 }
153
154 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
155 {
156 enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
157
158 printf("Hardware acceleration methods:\n");
159 while ((type = av_hwdevice_iterate_types(type)) !=
160 AV_HWDEVICE_TYPE_NONE)
161 printf("%s\n", av_hwdevice_get_type_name(type));
162 printf("\n");
163 return 0;
164 }
165
166 /* return a copy of the input with the stream specifiers removed from the keys */
167 12990 AVDictionary *strip_specifiers(const AVDictionary *dict)
168 {
169 12990 const AVDictionaryEntry *e = NULL;
170 12990 AVDictionary *ret = NULL;
171
172
2/2
✓ Branch 1 taken 36862 times.
✓ Branch 2 taken 12990 times.
49852 while ((e = av_dict_iterate(dict, e))) {
173 36862 char *p = strchr(e->key, ':');
174
175
2/2
✓ Branch 0 taken 216 times.
✓ Branch 1 taken 36646 times.
36862 if (p)
176 216 *p = 0;
177 36862 av_dict_set(&ret, e->key, e->value, 0);
178
2/2
✓ Branch 0 taken 216 times.
✓ Branch 1 taken 36646 times.
36862 if (p)
179 216 *p = ':';
180 }
181 12990 return ret;
182 }
183
184 496 int parse_and_set_vsync(const char *arg, int *vsync_var, int file_idx, int st_idx, int is_global)
185 {
186
2/2
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 490 times.
496 if (!av_strcasecmp(arg, "cfr")) *vsync_var = VSYNC_CFR;
187
2/2
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 489 times.
490 else if (!av_strcasecmp(arg, "vfr")) *vsync_var = VSYNC_VFR;
188
1/2
✓ Branch 1 taken 489 times.
✗ Branch 2 not taken.
489 else if (!av_strcasecmp(arg, "passthrough")) *vsync_var = VSYNC_PASSTHROUGH;
189 else if (!av_strcasecmp(arg, "drop")) *vsync_var = VSYNC_DROP;
190 else if (!is_global && !av_strcasecmp(arg, "auto")) *vsync_var = VSYNC_AUTO;
191 else if (!is_global) {
192 av_log(NULL, AV_LOG_FATAL, "Invalid value %s specified for fps_mode of #%d:%d.\n", arg, file_idx, st_idx);
193 exit_program(1);
194 }
195
196
2/4
✓ Branch 0 taken 496 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 496 times.
496 if (is_global && *vsync_var == VSYNC_AUTO) {
197 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
198 av_log(NULL, AV_LOG_WARNING, "Passing a number to -vsync is deprecated,"
199 " use a string argument as described in the manual.\n");
200 }
201 496 return 0;
202 }
203
204 /* Correct input file start times based on enabled streams */
205 6477 static void correct_input_start_times(void)
206 {
207
2/2
✓ Branch 0 taken 6511 times.
✓ Branch 1 taken 6477 times.
12988 for (int i = 0; i < nb_input_files; i++) {
208 6511 InputFile *ifile = input_files[i];
209 6511 AVFormatContext *is = ifile->ctx;
210 6511 int64_t new_start_time = INT64_MAX, diff, abs_start_seek;
211
212 6511 ifile->start_time_effective = is->start_time;
213
214
2/2
✓ Branch 0 taken 4946 times.
✓ Branch 1 taken 1565 times.
6511 if (is->start_time == AV_NOPTS_VALUE ||
215
2/2
✓ Branch 0 taken 4841 times.
✓ Branch 1 taken 105 times.
4946 !(is->iformat->flags & AVFMT_TS_DISCONT))
216 6406 continue;
217
218
2/2
✓ Branch 0 taken 155 times.
✓ Branch 1 taken 105 times.
260 for (int j = 0; j < is->nb_streams; j++) {
219 155 AVStream *st = is->streams[j];
220
3/4
✓ Branch 0 taken 120 times.
✓ Branch 1 taken 35 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 120 times.
155 if(st->discard == AVDISCARD_ALL || st->start_time == AV_NOPTS_VALUE)
221 35 continue;
222
2/2
✓ Branch 0 taken 117 times.
✓ Branch 1 taken 3 times.
120 new_start_time = FFMIN(new_start_time, av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q));
223 }
224
225 105 diff = new_start_time - is->start_time;
226
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 102 times.
105 if (diff) {
227 3 av_log(NULL, AV_LOG_VERBOSE, "Correcting start time of Input #%d by %"PRId64" us.\n", i, diff);
228 3 ifile->start_time_effective = new_start_time;
229
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
3 if (copy_ts && start_at_zero)
230 ifile->ts_offset = -new_start_time;
231
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
3 else if (!copy_ts) {
232
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
3 abs_start_seek = is->start_time + (ifile->start_time != AV_NOPTS_VALUE) ? ifile->start_time : 0;
233
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
3 ifile->ts_offset = abs_start_seek > new_start_time ? -abs_start_seek : -new_start_time;
234 } else if (copy_ts)
235 ifile->ts_offset = 0;
236
237 3 ifile->ts_offset += ifile->input_ts_offset;
238 }
239 }
240 6477 }
241
242 6477 static int apply_sync_offsets(void)
243 {
244
2/2
✓ Branch 0 taken 6511 times.
✓ Branch 1 taken 6477 times.
12988 for (int i = 0; i < nb_input_files; i++) {
245 6511 InputFile *ref, *self = input_files[i];
246 int64_t adjustment;
247 int64_t self_start_time, ref_start_time, self_seek_start, ref_seek_start;
248 6511 int start_times_set = 1;
249
250
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 6511 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
6511 if (self->input_sync_ref == -1 || self->input_sync_ref == i) continue;
251 if (self->input_sync_ref >= nb_input_files || self->input_sync_ref < -1) {
252 av_log(NULL, AV_LOG_FATAL, "-isync for input %d references non-existent input %d.\n", i, self->input_sync_ref);
253 exit_program(1);
254 }
255
256 if (copy_ts && !start_at_zero) {
257 av_log(NULL, AV_LOG_FATAL, "Use of -isync requires that start_at_zero be set if copyts is set.\n");
258 exit_program(1);
259 }
260
261 ref = input_files[self->input_sync_ref];
262 if (ref->input_sync_ref != -1 && ref->input_sync_ref != self->input_sync_ref) {
263 av_log(NULL, AV_LOG_ERROR, "-isync for input %d references a resynced input %d. Sync not set.\n", i, self->input_sync_ref);
264 continue;
265 }
266
267 if (self->ctx->start_time_realtime != AV_NOPTS_VALUE && ref->ctx->start_time_realtime != AV_NOPTS_VALUE) {
268 self_start_time = self->ctx->start_time_realtime;
269 ref_start_time = ref->ctx->start_time_realtime;
270 } else if (self->start_time_effective != AV_NOPTS_VALUE && ref->start_time_effective != AV_NOPTS_VALUE) {
271 self_start_time = self->start_time_effective;
272 ref_start_time = ref->start_time_effective;
273 } else {
274 start_times_set = 0;
275 }
276
277 if (start_times_set) {
278 self_seek_start = self->start_time == AV_NOPTS_VALUE ? 0 : self->start_time;
279 ref_seek_start = ref->start_time == AV_NOPTS_VALUE ? 0 : ref->start_time;
280
281 adjustment = (self_start_time - ref_start_time) + !copy_ts*(self_seek_start - ref_seek_start) + ref->input_ts_offset;
282
283 self->ts_offset += adjustment;
284
285 av_log(NULL, AV_LOG_INFO, "Adjusted ts offset for Input #%d by %"PRId64" us to sync with Input #%d.\n", i, adjustment, self->input_sync_ref);
286 } else {
287 av_log(NULL, AV_LOG_INFO, "Unable to identify start times for Inputs #%d and %d both. No sync adjustment made.\n", i, self->input_sync_ref);
288 }
289 }
290
291 6477 return 0;
292 }
293
294 314 static int opt_filter_threads(void *optctx, const char *opt, const char *arg)
295 {
296 314 av_free(filter_nbthreads);
297 314 filter_nbthreads = av_strdup(arg);
298 314 return 0;
299 }
300
301 static int opt_abort_on(void *optctx, const char *opt, const char *arg)
302 {
303 static const AVOption opts[] = {
304 { "abort_on" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
305 { "empty_output" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT }, .unit = "flags" },
306 { "empty_output_stream", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT_STREAM }, .unit = "flags" },
307 { NULL },
308 };
309 static const AVClass class = {
310 .class_name = "",
311 .item_name = av_default_item_name,
312 .option = opts,
313 .version = LIBAVUTIL_VERSION_INT,
314 };
315 const AVClass *pclass = &class;
316
317 return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
318 }
319
320 static int opt_stats_period(void *optctx, const char *opt, const char *arg)
321 {
322 int64_t user_stats_period = parse_time_or_die(opt, arg, 1);
323
324 if (user_stats_period <= 0) {
325 av_log(NULL, AV_LOG_ERROR, "stats_period %s must be positive.\n", arg);
326 return AVERROR(EINVAL);
327 }
328
329 stats_period = user_stats_period;
330 av_log(NULL, AV_LOG_INFO, "ffmpeg stats and -progress period set to %s.\n", arg);
331
332 return 0;
333 }
334
335 14 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
336 {
337 14 OptionsContext *o = optctx;
338 14 return parse_option(o, "codec:a", arg, options);
339 }
340
341 4575 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
342 {
343 4575 OptionsContext *o = optctx;
344 4575 return parse_option(o, "codec:v", arg, options);
345 }
346
347 2 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
348 {
349 2 OptionsContext *o = optctx;
350 2 return parse_option(o, "codec:s", arg, options);
351 }
352
353 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
354 {
355 OptionsContext *o = optctx;
356 return parse_option(o, "codec:d", arg, options);
357 }
358
359 171 static int opt_map(void *optctx, const char *opt, const char *arg)
360 {
361 171 OptionsContext *o = optctx;
362 171 StreamMap *m = NULL;
363 171 int i, negative = 0, file_idx, disabled = 0;
364 #if FFMPEG_OPT_MAP_SYNC
365 char *sync;
366 #endif
367 char *map, *p;
368 char *allow_unused;
369
370
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 171 times.
171 if (*arg == '-') {
371 negative = 1;
372 arg++;
373 }
374 171 map = av_strdup(arg);
375
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 171 times.
171 if (!map)
376 return AVERROR(ENOMEM);
377
378 #if FFMPEG_OPT_MAP_SYNC
379 /* parse sync stream first, just pick first matching stream */
380
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 171 times.
171 if (sync = strchr(map, ',')) {
381 *sync = 0;
382 av_log(NULL, AV_LOG_WARNING, "Specifying a sync stream is deprecated and has no effect\n");
383 }
384 #endif
385
386
387
2/2
✓ Branch 0 taken 19 times.
✓ Branch 1 taken 152 times.
171 if (map[0] == '[') {
388 /* this mapping refers to lavfi output */
389 19 const char *c = map + 1;
390 19 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
391 19 m = &o->stream_maps[o->nb_stream_maps - 1];
392 19 m->linklabel = av_get_token(&c, "]");
393
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 19 times.
19 if (!m->linklabel) {
394 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
395 exit_program(1);
396 }
397 } else {
398
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 152 times.
152 if (allow_unused = strchr(map, '?'))
399 *allow_unused = 0;
400 152 file_idx = strtol(map, &p, 0);
401
2/4
✓ Branch 0 taken 152 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 152 times.
152 if (file_idx >= nb_input_files || file_idx < 0) {
402 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
403 exit_program(1);
404 }
405
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 152 times.
152 if (negative)
406 /* disable some already defined maps */
407 for (i = 0; i < o->nb_stream_maps; i++) {
408 m = &o->stream_maps[i];
409 if (file_idx == m->file_index &&
410 check_stream_specifier(input_files[m->file_index]->ctx,
411 input_files[m->file_index]->ctx->streams[m->stream_index],
412 *p == ':' ? p + 1 : p) > 0)
413 m->disabled = 1;
414 }
415 else
416
2/2
✓ Branch 0 taken 345 times.
✓ Branch 1 taken 152 times.
497 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
417
2/2
✓ Branch 1 taken 128 times.
✓ Branch 2 taken 217 times.
345 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
418
2/2
✓ Branch 0 taken 194 times.
✓ Branch 1 taken 151 times.
345 *p == ':' ? p + 1 : p) <= 0)
419 128 continue;
420
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 217 times.
217 if (input_files[file_idx]->streams[i]->user_set_discard == AVDISCARD_ALL) {
421 disabled = 1;
422 continue;
423 }
424 217 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
425 217 m = &o->stream_maps[o->nb_stream_maps - 1];
426
427 217 m->file_index = file_idx;
428 217 m->stream_index = i;
429 }
430 }
431
432
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 171 times.
171 if (!m) {
433 if (allow_unused) {
434 av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
435 } else if (disabled) {
436 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches disabled streams.\n"
437 "To ignore this, add a trailing '?' to the map.\n", arg);
438 exit_program(1);
439 } else {
440 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
441 "To ignore this, add a trailing '?' to the map.\n", arg);
442 exit_program(1);
443 }
444 }
445
446 171 av_freep(&map);
447 171 return 0;
448 }
449
450 1 static int opt_attach(void *optctx, const char *opt, const char *arg)
451 {
452 1 OptionsContext *o = optctx;
453 1 GROW_ARRAY(o->attachments, o->nb_attachments);
454 1 o->attachments[o->nb_attachments - 1] = arg;
455 1 return 0;
456 }
457
458 #if FFMPEG_OPT_MAP_CHANNEL
459 10 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
460 {
461 10 OptionsContext *o = optctx;
462 int n;
463 AVStream *st;
464 AudioChannelMap *m;
465 char *allow_unused;
466 char *mapchan;
467
468 10 av_log(NULL, AV_LOG_WARNING,
469 "The -%s option is deprecated and will be removed. "
470 "It can be replaced by the 'pan' filter, or in some cases by "
471 "combinations of 'channelsplit', 'channelmap', 'amerge' filters.\n", opt);
472
473 10 mapchan = av_strdup(arg);
474
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
10 if (!mapchan)
475 return AVERROR(ENOMEM);
476
477 10 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
478 10 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
479
480 /* muted channel syntax */
481 10 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
482
3/6
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 9 times.
10 if ((n == 1 || n == 3) && m->channel_idx == -1) {
483 1 m->file_idx = m->stream_idx = -1;
484
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
1 if (n == 1)
485 1 m->ofile_idx = m->ostream_idx = -1;
486 1 av_free(mapchan);
487 1 return 0;
488 }
489
490 /* normal syntax */
491 9 n = sscanf(arg, "%d.%d.%d:%d.%d",
492 &m->file_idx, &m->stream_idx, &m->channel_idx,
493 &m->ofile_idx, &m->ostream_idx);
494
495
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
9 if (n != 3 && n != 5) {
496 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
497 "[file.stream.channel|-1][:syncfile:syncstream]\n");
498 exit_program(1);
499 }
500
501
1/2
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
9 if (n != 5) // only file.stream.channel specified
502 9 m->ofile_idx = m->ostream_idx = -1;
503
504 /* check input */
505
2/4
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 9 times.
9 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
506 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
507 m->file_idx);
508 exit_program(1);
509 }
510
1/2
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
9 if (m->stream_idx < 0 ||
511
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.
9 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
512 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
513 m->file_idx, m->stream_idx);
514 exit_program(1);
515 }
516 9 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
517
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.
9 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
518 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
519 m->file_idx, m->stream_idx);
520 exit_program(1);
521 }
522 /* allow trailing ? to map_channel */
523
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 7 times.
9 if (allow_unused = strchr(mapchan, '?'))
524 2 *allow_unused = 0;
525
3/4
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8 times.
✓ Branch 3 taken 1 times.
9 if (m->channel_idx < 0 || m->channel_idx >= st->codecpar->ch_layout.nb_channels ||
526
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
8 input_files[m->file_idx]->streams[m->stream_idx]->user_set_discard == AVDISCARD_ALL) {
527
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
1 if (allow_unused) {
528 1 av_log(NULL, AV_LOG_VERBOSE, "mapchan: invalid audio channel #%d.%d.%d\n",
529 m->file_idx, m->stream_idx, m->channel_idx);
530 } else {
531 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n"
532 "To ignore this, add a trailing '?' to the map_channel.\n",
533 m->file_idx, m->stream_idx, m->channel_idx);
534 exit_program(1);
535 }
536
537 }
538 9 av_free(mapchan);
539 9 return 0;
540 }
541 #endif
542
543 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
544 {
545 av_free(sdp_filename);
546 sdp_filename = av_strdup(arg);
547 return 0;
548 }
549
550 #if CONFIG_VAAPI
551 static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
552 {
553 const char *prefix = "vaapi:";
554 char *tmp;
555 int err;
556 tmp = av_asprintf("%s%s", prefix, arg);
557 if (!tmp)
558 return AVERROR(ENOMEM);
559 err = hw_device_init_from_string(tmp, NULL);
560 av_free(tmp);
561 return err;
562 }
563 #endif
564
565 #if CONFIG_QSV
566 static int opt_qsv_device(void *optctx, const char *opt, const char *arg)
567 {
568 const char *prefix = "qsv=__qsv_device:hw_any,child_device=";
569 int err;
570 char *tmp = av_asprintf("%s%s", prefix, arg);
571
572 if (!tmp)
573 return AVERROR(ENOMEM);
574
575 err = hw_device_init_from_string(tmp, NULL);
576 av_free(tmp);
577
578 return err;
579 }
580 #endif
581
582 static int opt_init_hw_device(void *optctx, const char *opt, const char *arg)
583 {
584 if (!strcmp(arg, "list")) {
585 enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
586 printf("Supported hardware device types:\n");
587 while ((type = av_hwdevice_iterate_types(type)) !=
588 AV_HWDEVICE_TYPE_NONE)
589 printf("%s\n", av_hwdevice_get_type_name(type));
590 printf("\n");
591 exit_program(0);
592 } else {
593 return hw_device_init_from_string(arg, NULL);
594 }
595 }
596
597 static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
598 {
599 if (filter_hw_device) {
600 av_log(NULL, AV_LOG_ERROR, "Only one filter device can be used.\n");
601 return AVERROR(EINVAL);
602 }
603 filter_hw_device = hw_device_get_by_name(arg);
604 if (!filter_hw_device) {
605 av_log(NULL, AV_LOG_ERROR, "Invalid filter device %s.\n", arg);
606 return AVERROR(EINVAL);
607 }
608 return 0;
609 }
610
611 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
612 {
613 OptionsContext *o = optctx;
614 char buf[128];
615 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
616 struct tm time = *gmtime((time_t*)&recording_timestamp);
617 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
618 return -1;
619 parse_option(o, "metadata", buf, options);
620
621 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
622 "tag instead.\n", opt);
623 return 0;
624 }
625
626 11408 const AVCodec *find_codec_or_die(void *logctx, const char *name,
627 enum AVMediaType type, int encoder)
628 {
629 const AVCodecDescriptor *desc;
630
2/2
✓ Branch 0 taken 3466 times.
✓ Branch 1 taken 7942 times.
11408 const char *codec_string = encoder ? "encoder" : "decoder";
631 const AVCodec *codec;
632
633 11408 codec = encoder ?
634
2/2
✓ Branch 0 taken 3466 times.
✓ Branch 1 taken 7942 times.
11408 avcodec_find_encoder_by_name(name) :
635 7942 avcodec_find_decoder_by_name(name);
636
637
3/4
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 11407 times.
✓ Branch 3 taken 1 times.
✗ Branch 4 not taken.
11408 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
638
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
1 codec = encoder ? avcodec_find_encoder(desc->id) :
639 avcodec_find_decoder(desc->id);
640
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
1 if (codec)
641 1 av_log(logctx, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
642 1 codec_string, codec->name, desc->name);
643 }
644
645
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11408 times.
11408 if (!codec) {
646 av_log(logctx, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
647 exit_program(1);
648 }
649
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 11408 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
11408 if (codec->type != type && !recast_media) {
650 av_log(logctx, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
651 exit_program(1);
652 }
653 11408 return codec;
654 }
655
656 6399 void assert_file_overwrite(const char *filename)
657 {
658 6399 const char *proto_name = avio_find_protocol_name(filename);
659
660
3/4
✓ Branch 0 taken 1737 times.
✓ Branch 1 taken 4662 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1737 times.
6399 if (file_overwrite && no_file_overwrite) {
661 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
662 exit_program(1);
663 }
664
665
2/2
✓ Branch 0 taken 4662 times.
✓ Branch 1 taken 1737 times.
6399 if (!file_overwrite) {
666
2/6
✓ Branch 0 taken 4662 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 4662 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
4662 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
667 if (stdin_interaction && !no_file_overwrite) {
668 fprintf(stderr,"File '%s' already exists. Overwrite? [y/N] ", filename);
669 fflush(stderr);
670 term_exit();
671 signal(SIGINT, SIG_DFL);
672 if (!read_yesno()) {
673 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
674 exit_program(1);
675 }
676 term_init();
677 }
678 else {
679 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
680 exit_program(1);
681 }
682 }
683 }
684
685
3/4
✓ Branch 0 taken 6399 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1601 times.
✓ Branch 3 taken 4798 times.
6399 if (proto_name && !strcmp(proto_name, "file")) {
686
2/2
✓ Branch 0 taken 1647 times.
✓ Branch 1 taken 1601 times.
3248 for (int i = 0; i < nb_input_files; i++) {
687 1647 InputFile *file = input_files[i];
688
2/2
✓ Branch 0 taken 86 times.
✓ Branch 1 taken 1561 times.
1647 if (file->ctx->iformat->flags & AVFMT_NOFILE)
689 86 continue;
690
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1561 times.
1561 if (!strcmp(filename, file->ctx->url)) {
691 av_log(NULL, AV_LOG_FATAL, "Output %s same as Input #%d - exiting\n", filename, i);
692 av_log(NULL, AV_LOG_WARNING, "FFmpeg cannot edit existing files in-place.\n");
693 exit_program(1);
694 }
695 }
696 }
697 6399 }
698
699 /* read file contents into a string */
700 34 char *file_read(const char *filename)
701 {
702 34 AVIOContext *pb = NULL;
703 34 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
704 AVBPrint bprint;
705 char *str;
706
707
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 34 times.
34 if (ret < 0) {
708 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
709 return NULL;
710 }
711
712 34 av_bprint_init(&bprint, 0, AV_BPRINT_SIZE_UNLIMITED);
713 34 ret = avio_read_to_bprint(pb, &bprint, SIZE_MAX);
714 34 avio_closep(&pb);
715
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 34 times.
34 if (ret < 0) {
716 av_bprint_finalize(&bprint, NULL);
717 return NULL;
718 }
719 34 ret = av_bprint_finalize(&bprint, &str);
720
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 34 times.
34 if (ret < 0)
721 return NULL;
722 34 return str;
723 }
724
725 /* arg format is "output-stream-index:streamid-value". */
726 static int opt_streamid(void *optctx, const char *opt, const char *arg)
727 {
728 OptionsContext *o = optctx;
729 int idx;
730 char *p;
731 char idx_str[16];
732
733 av_strlcpy(idx_str, arg, sizeof(idx_str));
734 p = strchr(idx_str, ':');
735 if (!p) {
736 av_log(NULL, AV_LOG_FATAL,
737 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
738 arg, opt);
739 exit_program(1);
740 }
741 *p++ = '\0';
742 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
743 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
744 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
745 return 0;
746 }
747
748 6477 static int init_complex_filters(void)
749 {
750 6477 int i, ret = 0;
751
752
2/2
✓ Branch 0 taken 100 times.
✓ Branch 1 taken 6477 times.
6577 for (i = 0; i < nb_filtergraphs; i++) {
753 100 ret = init_complex_filtergraph(filtergraphs[i]);
754
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 100 times.
100 if (ret < 0)
755 return ret;
756 }
757 6477 return 0;
758 }
759
760 static int opt_target(void *optctx, const char *opt, const char *arg)
761 {
762 OptionsContext *o = optctx;
763 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
764 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
765
766 if (!strncmp(arg, "pal-", 4)) {
767 norm = PAL;
768 arg += 4;
769 } else if (!strncmp(arg, "ntsc-", 5)) {
770 norm = NTSC;
771 arg += 5;
772 } else if (!strncmp(arg, "film-", 5)) {
773 norm = FILM;
774 arg += 5;
775 } else {
776 /* Try to determine PAL/NTSC by peeking in the input files */
777 if (nb_input_files) {
778 int i, j;
779 for (j = 0; j < nb_input_files; j++) {
780 for (i = 0; i < input_files[j]->nb_streams; i++) {
781 AVStream *st = input_files[j]->ctx->streams[i];
782 int64_t fr;
783 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
784 continue;
785 fr = st->time_base.den * 1000LL / st->time_base.num;
786 if (fr == 25000) {
787 norm = PAL;
788 break;
789 } else if ((fr == 29970) || (fr == 23976)) {
790 norm = NTSC;
791 break;
792 }
793 }
794 if (norm != UNKNOWN)
795 break;
796 }
797 }
798 if (norm != UNKNOWN)
799 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
800 }
801
802 if (norm == UNKNOWN) {
803 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
804 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
805 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
806 exit_program(1);
807 }
808
809 if (!strcmp(arg, "vcd")) {
810 opt_video_codec(o, "c:v", "mpeg1video");
811 opt_audio_codec(o, "c:a", "mp2");
812 parse_option(o, "f", "vcd", options);
813
814 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
815 parse_option(o, "r", frame_rates[norm], options);
816 opt_default(NULL, "g", norm == PAL ? "15" : "18");
817
818 opt_default(NULL, "b:v", "1150000");
819 opt_default(NULL, "maxrate:v", "1150000");
820 opt_default(NULL, "minrate:v", "1150000");
821 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
822
823 opt_default(NULL, "b:a", "224000");
824 parse_option(o, "ar", "44100", options);
825 parse_option(o, "ac", "2", options);
826
827 opt_default(NULL, "packetsize", "2324");
828 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
829
830 /* We have to offset the PTS, so that it is consistent with the SCR.
831 SCR starts at 36000, but the first two packs contain only padding
832 and the first pack from the other stream, respectively, may also have
833 been written before.
834 So the real data starts at SCR 36000+3*1200. */
835 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
836 } else if (!strcmp(arg, "svcd")) {
837
838 opt_video_codec(o, "c:v", "mpeg2video");
839 opt_audio_codec(o, "c:a", "mp2");
840 parse_option(o, "f", "svcd", options);
841
842 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
843 parse_option(o, "r", frame_rates[norm], options);
844 parse_option(o, "pix_fmt", "yuv420p", options);
845 opt_default(NULL, "g", norm == PAL ? "15" : "18");
846
847 opt_default(NULL, "b:v", "2040000");
848 opt_default(NULL, "maxrate:v", "2516000");
849 opt_default(NULL, "minrate:v", "0"); // 1145000;
850 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
851 opt_default(NULL, "scan_offset", "1");
852
853 opt_default(NULL, "b:a", "224000");
854 parse_option(o, "ar", "44100", options);
855
856 opt_default(NULL, "packetsize", "2324");
857
858 } else if (!strcmp(arg, "dvd")) {
859
860 opt_video_codec(o, "c:v", "mpeg2video");
861 opt_audio_codec(o, "c:a", "ac3");
862 parse_option(o, "f", "dvd", options);
863
864 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
865 parse_option(o, "r", frame_rates[norm], options);
866 parse_option(o, "pix_fmt", "yuv420p", options);
867 opt_default(NULL, "g", norm == PAL ? "15" : "18");
868
869 opt_default(NULL, "b:v", "6000000");
870 opt_default(NULL, "maxrate:v", "9000000");
871 opt_default(NULL, "minrate:v", "0"); // 1500000;
872 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
873
874 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
875 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
876
877 opt_default(NULL, "b:a", "448000");
878 parse_option(o, "ar", "48000", options);
879
880 } else if (!strncmp(arg, "dv", 2)) {
881
882 parse_option(o, "f", "dv", options);
883
884 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
885 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
886 norm == PAL ? "yuv420p" : "yuv411p", options);
887 parse_option(o, "r", frame_rates[norm], options);
888
889 parse_option(o, "ar", "48000", options);
890 parse_option(o, "ac", "2", options);
891
892 } else {
893 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
894 return AVERROR(EINVAL);
895 }
896
897 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
898 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
899
900 return 0;
901 }
902
903 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
904 {
905 av_free (vstats_filename);
906 vstats_filename = av_strdup (arg);
907 return 0;
908 }
909
910 static int opt_vstats(void *optctx, const char *opt, const char *arg)
911 {
912 char filename[40];
913 time_t today2 = time(NULL);
914 struct tm *today = localtime(&today2);
915
916 if (!today) { // maybe tomorrow
917 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
918 exit_program(1);
919 }
920
921 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
922 today->tm_sec);
923 return opt_vstats_file(NULL, opt, filename);
924 }
925
926 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
927 {
928 OptionsContext *o = optctx;
929 return parse_option(o, "frames:v", arg, options);
930 }
931
932 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
933 {
934 OptionsContext *o = optctx;
935 return parse_option(o, "frames:a", arg, options);
936 }
937
938 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
939 {
940 OptionsContext *o = optctx;
941 return parse_option(o, "frames:d", arg, options);
942 }
943
944 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
945 {
946 int ret;
947 AVDictionary *cbak = codec_opts;
948 AVDictionary *fbak = format_opts;
949 codec_opts = NULL;
950 format_opts = NULL;
951
952 ret = opt_default(NULL, opt, arg);
953
954 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
955 av_dict_copy(&o->g->format_opts, format_opts, 0);
956 av_dict_free(&codec_opts);
957 av_dict_free(&format_opts);
958 codec_opts = cbak;
959 format_opts = fbak;
960
961 return ret;
962 }
963
964 static int opt_preset(void *optctx, const char *opt, const char *arg)
965 {
966 OptionsContext *o = optctx;
967 FILE *f=NULL;
968 char filename[1000], line[1000], tmp_line[1000];
969 const char *codec_name = NULL;
970
971 tmp_line[0] = *opt;
972 tmp_line[1] = 0;
973 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
974
975 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
976 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
977 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
978 }else
979 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
980 exit_program(1);
981 }
982
983 while (fgets(line, sizeof(line), f)) {
984 char *key = tmp_line, *value, *endptr;
985
986 if (strcspn(line, "#\n\r") == 0)
987 continue;
988 av_strlcpy(tmp_line, line, sizeof(tmp_line));
989 if (!av_strtok(key, "=", &value) ||
990 !av_strtok(value, "\r\n", &endptr)) {
991 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
992 exit_program(1);
993 }
994 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
995
996 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
997 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
998 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
999 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
1000 else if (opt_default_new(o, key, value) < 0) {
1001 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
1002 filename, line, key, value);
1003 exit_program(1);
1004 }
1005 }
1006
1007 fclose(f);
1008
1009 return 0;
1010 }
1011
1012 3 static int opt_old2new(void *optctx, const char *opt, const char *arg)
1013 {
1014 3 OptionsContext *o = optctx;
1015 int ret;
1016 3 char *s = av_asprintf("%s:%c", opt + 1, *opt);
1017
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
3 if (!s)
1018 return AVERROR(ENOMEM);
1019 3 ret = parse_option(o, s, arg, options);
1020 3 av_free(s);
1021 3 return ret;
1022 }
1023
1024 166 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
1025 {
1026 166 OptionsContext *o = optctx;
1027
1028
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 165 times.
166 if(!strcmp(opt, "ab")){
1029 1 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
1030 1 return 0;
1031
2/2
✓ Branch 0 taken 43 times.
✓ Branch 1 taken 122 times.
165 } else if(!strcmp(opt, "b")){
1032 43 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
1033 43 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
1034 43 return 0;
1035 }
1036 122 av_dict_set(&o->g->codec_opts, opt, arg, 0);
1037 122 return 0;
1038 }
1039
1040 280 static int opt_qscale(void *optctx, const char *opt, const char *arg)
1041 {
1042 280 OptionsContext *o = optctx;
1043 char *s;
1044 int ret;
1045
2/2
✓ Branch 0 taken 239 times.
✓ Branch 1 taken 41 times.
280 if(!strcmp(opt, "qscale")){
1046 239 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
1047 239 return parse_option(o, "q:v", arg, options);
1048 }
1049 41 s = av_asprintf("q%s", opt + 6);
1050
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 41 times.
41 if (!s)
1051 return AVERROR(ENOMEM);
1052 41 ret = parse_option(o, s, arg, options);
1053 41 av_free(s);
1054 41 return ret;
1055 }
1056
1057 45 static int opt_profile(void *optctx, const char *opt, const char *arg)
1058 {
1059 45 OptionsContext *o = optctx;
1060
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 41 times.
45 if(!strcmp(opt, "profile")){
1061 4 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
1062 4 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
1063 4 return 0;
1064 }
1065 41 av_dict_set(&o->g->codec_opts, opt, arg, 0);
1066 41 return 0;
1067 }
1068
1069 2717 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
1070 {
1071 2717 OptionsContext *o = optctx;
1072 2717 return parse_option(o, "filter:v", arg, options);
1073 }
1074
1075 555 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
1076 {
1077 555 OptionsContext *o = optctx;
1078 555 return parse_option(o, "filter:a", arg, options);
1079 }
1080
1081 496 static int opt_vsync(void *optctx, const char *opt, const char *arg)
1082 {
1083 496 av_log(NULL, AV_LOG_WARNING, "-vsync is deprecated. Use -fps_mode\n");
1084 496 parse_and_set_vsync(arg, &video_sync_method, -1, -1, 1);
1085 496 return 0;
1086 }
1087
1088 15 static int opt_timecode(void *optctx, const char *opt, const char *arg)
1089 {
1090 15 OptionsContext *o = optctx;
1091 int ret;
1092 15 char *tcr = av_asprintf("timecode=%s", arg);
1093
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 15 times.
15 if (!tcr)
1094 return AVERROR(ENOMEM);
1095 15 ret = parse_option(o, "metadata:g", tcr, options);
1096
1/2
✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
15 if (ret >= 0)
1097 15 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
1098 15 av_free(tcr);
1099 15 return ret;
1100 }
1101
1102 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
1103 {
1104 OptionsContext *o = optctx;
1105 return parse_option(o, "q:a", arg, options);
1106 }
1107
1108 74 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
1109 {
1110 74 FilterGraph *fg = ALLOC_ARRAY_ELEM(filtergraphs, nb_filtergraphs);
1111
1112 74 fg->index = nb_filtergraphs - 1;
1113 74 fg->graph_desc = av_strdup(arg);
1114
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 74 times.
74 if (!fg->graph_desc)
1115 return AVERROR(ENOMEM);
1116
1117 74 return 0;
1118 }
1119
1120 26 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
1121 {
1122 FilterGraph *fg;
1123 26 char *graph_desc = file_read(arg);
1124
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 26 times.
26 if (!graph_desc)
1125 return AVERROR(EINVAL);
1126
1127 26 fg = ALLOC_ARRAY_ELEM(filtergraphs, nb_filtergraphs);
1128 26 fg->index = nb_filtergraphs - 1;
1129 26 fg->graph_desc = graph_desc;
1130
1131 26 return 0;
1132 }
1133
1134 void show_help_default(const char *opt, const char *arg)
1135 {
1136 /* per-file options have at least one of those set */
1137 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
1138 int show_advanced = 0, show_avoptions = 0;
1139
1140 if (opt && *opt) {
1141 if (!strcmp(opt, "long"))
1142 show_advanced = 1;
1143 else if (!strcmp(opt, "full"))
1144 show_advanced = show_avoptions = 1;
1145 else
1146 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
1147 }
1148
1149 show_usage();
1150
1151 printf("Getting help:\n"
1152 " -h -- print basic options\n"
1153 " -h long -- print more options\n"
1154 " -h full -- print all options (including all format and codec specific options, very long)\n"
1155 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter/bsf/protocol\n"
1156 " See man %s for detailed description of the options.\n"
1157 "\n", program_name);
1158
1159 show_help_options(options, "Print help / information / capabilities:",
1160 OPT_EXIT, 0, 0);
1161
1162 show_help_options(options, "Global options (affect whole program "
1163 "instead of just one file):",
1164 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
1165 if (show_advanced)
1166 show_help_options(options, "Advanced global options:", OPT_EXPERT,
1167 per_file | OPT_EXIT, 0);
1168
1169 show_help_options(options, "Per-file main options:", 0,
1170 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
1171 OPT_EXIT, per_file);
1172 if (show_advanced)
1173 show_help_options(options, "Advanced per-file options:",
1174 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
1175
1176 show_help_options(options, "Video options:",
1177 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
1178 if (show_advanced)
1179 show_help_options(options, "Advanced Video options:",
1180 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
1181
1182 show_help_options(options, "Audio options:",
1183 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
1184 if (show_advanced)
1185 show_help_options(options, "Advanced Audio options:",
1186 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
1187 show_help_options(options, "Subtitle options:",
1188 OPT_SUBTITLE, 0, 0);
1189 printf("\n");
1190
1191 if (show_avoptions) {
1192 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
1193 show_help_children(avcodec_get_class(), flags);
1194 show_help_children(avformat_get_class(), flags);
1195 #if CONFIG_SWSCALE
1196 show_help_children(sws_get_class(), flags);
1197 #endif
1198 #if CONFIG_SWRESAMPLE
1199 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
1200 #endif
1201 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
1202 show_help_children(av_bsf_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_BSF_PARAM);
1203 }
1204 }
1205
1206 void show_usage(void)
1207 {
1208 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
1209 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
1210 av_log(NULL, AV_LOG_INFO, "\n");
1211 }
1212
1213 enum OptGroup {
1214 GROUP_OUTFILE,
1215 GROUP_INFILE,
1216 };
1217
1218 static const OptionGroupDef groups[] = {
1219 [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
1220 [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
1221 };
1222
1223 12954 static int open_files(OptionGroupList *l, const char *inout,
1224 int (*open_file)(const OptionsContext*, const char*))
1225 {
1226 int i, ret;
1227
1228
2/2
✓ Branch 0 taken 12990 times.
✓ Branch 1 taken 12954 times.
25944 for (i = 0; i < l->nb_groups; i++) {
1229 12990 OptionGroup *g = &l->groups[i];
1230 OptionsContext o;
1231
1232 12990 init_options(&o);
1233 12990 o.g = g;
1234
1235 12990 ret = parse_optgroup(&o, g);
1236
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12990 times.
12990 if (ret < 0) {
1237 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
1238 "%s.\n", inout, g->arg);
1239 uninit_options(&o);
1240 return ret;
1241 }
1242
1243 12990 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
1244 12990 ret = open_file(&o, g->arg);
1245 12990 uninit_options(&o);
1246
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12990 times.
12990 if (ret < 0) {
1247 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
1248 inout, g->arg);
1249 return ret;
1250 }
1251 12990 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
1252 }
1253
1254 12954 return 0;
1255 }
1256
1257 6478 int ffmpeg_parse_options(int argc, char **argv)
1258 {
1259 OptionParseContext octx;
1260 int ret;
1261
1262 6478 memset(&octx, 0, sizeof(octx));
1263
1264 /* split the commandline into an internal representation */
1265 6478 ret = split_commandline(&octx, argc, argv, options, groups,
1266 FF_ARRAY_ELEMS(groups));
1267
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6478 times.
6478 if (ret < 0) {
1268 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
1269 goto fail;
1270 }
1271
1272 /* apply global options */
1273 6478 ret = parse_optgroup(NULL, &octx.global_opts);
1274
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6477 times.
6477 if (ret < 0) {
1275 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
1276 goto fail;
1277 }
1278
1279 /* configure terminal and setup signal handlers */
1280 6477 term_init();
1281
1282 /* open input files */
1283 6477 ret = open_files(&octx.groups[GROUP_INFILE], "input", ifile_open);
1284
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6477 times.
6477 if (ret < 0) {
1285 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
1286 goto fail;
1287 }
1288
1289 /* create the complex filtergraphs */
1290 6477 ret = init_complex_filters();
1291
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6477 times.
6477 if (ret < 0) {
1292 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
1293 goto fail;
1294 }
1295
1296 /* open output files */
1297 6477 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", of_open);
1298
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6477 times.
6477 if (ret < 0) {
1299 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
1300 goto fail;
1301 }
1302
1303 6477 correct_input_start_times();
1304
1305 6477 apply_sync_offsets();
1306
1307 6477 check_filter_outputs();
1308
1309 6477 fail:
1310 6477 uninit_parse_context(&octx);
1311
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6477 times.
6477 if (ret < 0) {
1312 av_log(NULL, AV_LOG_FATAL, "%s\n", av_err2str(ret));
1313 }
1314 6477 return ret;
1315 }
1316
1317 static int opt_progress(void *optctx, const char *opt, const char *arg)
1318 {
1319 AVIOContext *avio = NULL;
1320 int ret;
1321
1322 if (!strcmp(arg, "-"))
1323 arg = "pipe:";
1324 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
1325 if (ret < 0) {
1326 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
1327 arg, av_err2str(ret));
1328 return ret;
1329 }
1330 progress_avio = avio;
1331 return 0;
1332 }
1333
1334 int opt_timelimit(void *optctx, const char *opt, const char *arg)
1335 {
1336 #if HAVE_SETRLIMIT
1337 int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
1338 struct rlimit rl = { lim, lim + 1 };
1339 if (setrlimit(RLIMIT_CPU, &rl))
1340 perror("setrlimit");
1341 #else
1342 av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);
1343 #endif
1344 return 0;
1345 }
1346
1347 #define OFFSET(x) offsetof(OptionsContext, x)
1348 const OptionDef options[] = {
1349 /* main options */
1350 CMDUTILS_COMMON_OPTIONS
1351 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
1352 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
1353 "force format", "fmt" },
1354 { "y", OPT_BOOL, { &file_overwrite },
1355 "overwrite output files" },
1356 { "n", OPT_BOOL, { &no_file_overwrite },
1357 "never overwrite output files" },
1358 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
1359 "Ignore unknown stream types" },
1360 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { &copy_unknown_streams },
1361 "Copy unknown stream types" },
1362 { "recast_media", OPT_BOOL | OPT_EXPERT, { &recast_media },
1363 "allow recasting stream type in order to force a decoder of different media type" },
1364 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
1365 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
1366 "codec name", "codec" },
1367 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
1368 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
1369 "codec name", "codec" },
1370 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
1371 OPT_OUTPUT, { .off = OFFSET(presets) },
1372 "preset name", "preset" },
1373 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
1374 OPT_OUTPUT, { .func_arg = opt_map },
1375 "set input stream mapping",
1376 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
1377 #if FFMPEG_OPT_MAP_CHANNEL
1378 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
1379 "map an audio channel from one stream to another (deprecated)", "file.stream.channel[:syncfile.syncstream]" },
1380 #endif
1381 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
1382 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
1383 "set metadata information of outfile from infile",
1384 "outfile[,metadata]:infile[,metadata]" },
1385 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
1386 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
1387 "set chapters mapping", "input_file_index" },
1388 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
1389 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
1390 "record or transcode \"duration\" seconds of audio/video",
1391 "duration" },
1392 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(stop_time) },
1393 "record or transcode stop time", "time_stop" },
1394 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
1395 "set the limit file size in bytes", "limit_size" },
1396 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
1397 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
1398 "set the start time offset", "time_off" },
1399 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
1400 OPT_INPUT, { .off = OFFSET(start_time_eof) },
1401 "set the start time offset relative to EOF", "time_off" },
1402 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
1403 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
1404 "enable/disable seeking by timestamp with -ss" },
1405 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
1406 OPT_INPUT, { .off = OFFSET(accurate_seek) },
1407 "enable/disable accurate seeking with -ss" },
1408 { "isync", HAS_ARG | OPT_INT | OPT_OFFSET |
1409 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_sync_ref) },
1410 "Indicate the input index for sync reference", "sync ref" },
1411 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
1412 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
1413 "set the input ts offset", "time_off" },
1414 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
1415 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
1416 "set the input ts scale", "scale" },
1417 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
1418 "set the recording timestamp ('now' to set the current time)", "time" },
1419 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
1420 "add metadata", "string=string" },
1421 { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
1422 "add program with specified streams", "title=string:st=number..." },
1423 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
1424 OPT_OUTPUT, { .func_arg = opt_data_frames },
1425 "set the number of data frames to output", "number" },
1426 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
1427 "add timings for benchmarking" },
1428 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
1429 "add timings for each task" },
1430 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
1431 "write program-readable progress information", "url" },
1432 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
1433 "enable or disable interaction on standard input" },
1434 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
1435 "set max runtime in seconds in CPU user time", "limit" },
1436 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
1437 "dump each input packet" },
1438 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
1439 "when dumping packets, also dump the payload" },
1440 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
1441 OPT_INPUT, { .off = OFFSET(rate_emu) },
1442 "read input at native frame rate; equivalent to -readrate 1", "" },
1443 { "readrate", HAS_ARG | OPT_FLOAT | OPT_OFFSET |
1444 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(readrate) },
1445 "read input at specified rate", "speed" },
1446 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
1447 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
1448 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
1449 { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
1450 "set video sync method globally; deprecated, use -fps_mode", "" },
1451 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
1452 "frame drop threshold", "" },
1453 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
1454 "audio drift threshold", "threshold" },
1455 { "copyts", OPT_BOOL | OPT_EXPERT, { &copy_ts },
1456 "copy timestamps" },
1457 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
1458 "shift input timestamps to start at 0 when using copyts" },
1459 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { &copy_tb },
1460 "copy input stream time base when stream copying", "mode" },
1461 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
1462 OPT_OUTPUT, { .off = OFFSET(shortest) },
1463 "finish encoding within shortest input" },
1464 { "shortest_buf_duration", HAS_ARG | OPT_FLOAT | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(shortest_buf_duration) },
1465 "maximum buffering duration (in seconds) for the -shortest option" },
1466 { "bitexact", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
1467 OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(bitexact) },
1468 "bitexact mode" },
1469 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
1470 OPT_OUTPUT, { .off = OFFSET(apad) },
1471 "audio pad", "" },
1472 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
1473 "timestamp discontinuity delta threshold", "threshold" },
1474 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
1475 "timestamp error delta threshold", "threshold" },
1476 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
1477 "exit on error", "error" },
1478 { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
1479 "abort on the specified condition flags", "flags" },
1480 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
1481 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
1482 "copy initial non-keyframes" },
1483 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
1484 "copy or discard frames before start time" },
1485 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
1486 "set the number of frames to output", "number" },
1487 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
1488 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
1489 "force codec tag/fourcc", "fourcc/tag" },
1490 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
1491 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
1492 "use fixed quality scale (VBR)", "q" },
1493 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
1494 OPT_OUTPUT, { .func_arg = opt_qscale },
1495 "use fixed quality scale (VBR)", "q" },
1496 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
1497 "set profile", "profile" },
1498 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
1499 "set stream filtergraph", "filter_graph" },
1500 { "filter_threads", HAS_ARG, { .func_arg = opt_filter_threads },
1501 "number of non-complex filter threads" },
1502 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
1503 "read stream filtergraph description from a file", "filename" },
1504 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
1505 "reinit filtergraph on input parameter changes", "" },
1506 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
1507 "create a complex filtergraph", "graph_description" },
1508 { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
1509 "number of threads for -filter_complex" },
1510 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
1511 "create a complex filtergraph", "graph_description" },
1512 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
1513 "read complex filtergraph description from a file", "filename" },
1514 { "auto_conversion_filters", OPT_BOOL | OPT_EXPERT, { &auto_conversion_filters },
1515 "enable automatic conversion filters globally" },
1516 { "stats", OPT_BOOL, { &print_stats },
1517 "print progress report during encoding", },
1518 { "stats_period", HAS_ARG | OPT_EXPERT, { .func_arg = opt_stats_period },
1519 "set the period at which ffmpeg updates stats and -progress output", "time" },
1520 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
1521 OPT_OUTPUT, { .func_arg = opt_attach },
1522 "add an attachment to the output file", "filename" },
1523 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
1524 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
1525 "extract an attachment into a file", "filename" },
1526 { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
1527 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
1528 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
1529 "print timestamp debugging info" },
1530 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
1531 "ratio of decoding errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success.", "maximum error rate" },
1532 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
1533 OPT_INPUT, { .off = OFFSET(discard) },
1534 "discard", "" },
1535 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
1536 OPT_OUTPUT, { .off = OFFSET(disposition) },
1537 "disposition", "" },
1538 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT,
1539 { .off = OFFSET(thread_queue_size) },
1540 "set the maximum number of queued packets from the demuxer" },
1541 { "find_stream_info", OPT_BOOL | OPT_INPUT | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(find_stream_info) },
1542 "read and decode the streams to fill missing information with heuristics" },
1543 { "bits_per_raw_sample", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,
1544 { .off = OFFSET(bits_per_raw_sample) },
1545 "set the number of bits per raw sample", "number" },
1546
1547 { "stats_enc_pre", HAS_ARG | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT | OPT_STRING, { .off = OFFSET(enc_stats_pre) },
1548 "write encoding stats before encoding" },
1549 { "stats_enc_post", HAS_ARG | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT | OPT_STRING, { .off = OFFSET(enc_stats_post) },
1550 "write encoding stats after encoding" },
1551 { "stats_mux_pre", HAS_ARG | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT | OPT_STRING, { .off = OFFSET(mux_stats) },
1552 "write packets stats before muxing" },
1553 { "stats_enc_pre_fmt", HAS_ARG | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT | OPT_STRING, { .off = OFFSET(enc_stats_pre_fmt) },
1554 "format of the stats written with -stats_enc_pre" },
1555 { "stats_enc_post_fmt", HAS_ARG | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT | OPT_STRING, { .off = OFFSET(enc_stats_post_fmt) },
1556 "format of the stats written with -stats_enc_post" },
1557 { "stats_mux_pre_fmt", HAS_ARG | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT | OPT_STRING, { .off = OFFSET(mux_stats_fmt) },
1558 "format of the stats written with -stats_mux_pre" },
1559
1560 /* video options */
1561 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
1562 "set the number of video frames to output", "number" },
1563 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
1564 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
1565 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
1566 { "fpsmax", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
1567 OPT_OUTPUT, { .off = OFFSET(max_frame_rates) },
1568 "set max frame rate (Hz value, fraction or abbreviation)", "rate" },
1569 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
1570 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
1571 "set frame size (WxH or abbreviation)", "size" },
1572 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
1573 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
1574 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
1575 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
1576 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
1577 "set pixel format", "format" },
1578 { "display_rotation", OPT_VIDEO | HAS_ARG | OPT_DOUBLE | OPT_SPEC |
1579 OPT_INPUT, { .off = OFFSET(display_rotations) },
1580 "set pure counter-clockwise rotation in degrees for stream(s)",
1581 "angle" },
1582 { "display_hflip", OPT_VIDEO | OPT_BOOL | OPT_SPEC | OPT_INPUT, { .off = OFFSET(display_hflips) },
1583 "set display horizontal flip for stream(s) "
1584 "(overrides any display rotation if it is not set)"},
1585 { "display_vflip", OPT_VIDEO | OPT_BOOL | OPT_SPEC | OPT_INPUT, { .off = OFFSET(display_vflips) },
1586 "set display vertical flip for stream(s) "
1587 "(overrides any display rotation if it is not set)"},
1588 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
1589 "disable video" },
1590 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
1591 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
1592 "rate control override for specific intervals", "override" },
1593 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
1594 OPT_OUTPUT, { .func_arg = opt_video_codec },
1595 "force video codec ('copy' to copy stream)", "codec" },
1596 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
1597 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
1598 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
1599 "select the pass number (1 to 3)", "n" },
1600 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
1601 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
1602 "select two pass log file name prefix", "prefix" },
1603 #if FFMPEG_OPT_PSNR
1604 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
1605 "calculate PSNR of compressed frames (deprecated, use -flags +psnr)" },
1606 #endif
1607 { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
1608 "dump video coding statistics to file" },
1609 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
1610 "dump video coding statistics to file", "file" },
1611 { "vstats_version", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &vstats_version },
1612 "Version of the vstats format to use."},
1613 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
1614 "set video filters", "filter_graph" },
1615 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
1616 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
1617 "specify intra matrix coeffs", "matrix" },
1618 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
1619 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
1620 "specify inter matrix coeffs", "matrix" },
1621 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
1622 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
1623 "specify intra matrix coeffs", "matrix" },
1624 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
1625 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
1626 "top=1/bottom=0/auto=-1 field first", "" },
1627 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
1628 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
1629 "force video tag/fourcc", "fourcc/tag" },
1630 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
1631 "show QP histogram" },
1632 { "fps_mode", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT |
1633 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(fps_mode) },
1634 "set framerate mode for matching video streams; overrides vsync" },
1635 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
1636 OPT_OUTPUT, { .off = OFFSET(force_fps) },
1637 "force the selected framerate, disable the best supported framerate selection" },
1638 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
1639 OPT_OUTPUT, { .func_arg = opt_streamid },
1640 "set the value of an outfile streamid", "streamIndex:value" },
1641 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
1642 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
1643 "force key frames at specified timestamps", "timestamps" },
1644 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
1645 "video bitrate (please use -b:v)", "bitrate" },
1646 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
1647 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
1648 "use HW accelerated decoding", "hwaccel name" },
1649 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
1650 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
1651 "select a device for HW acceleration", "devicename" },
1652 { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
1653 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
1654 "select output format used with HW accelerated decoding", "format" },
1655 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
1656 "show available HW acceleration methods" },
1657 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
1658 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
1659 "automatically insert correct rotate filters" },
1660 { "autoscale", HAS_ARG | OPT_BOOL | OPT_SPEC |
1661 OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(autoscale) },
1662 "automatically insert a scale filter at the end of the filter graph" },
1663 { "fix_sub_duration_heartbeat", OPT_VIDEO | OPT_BOOL | OPT_EXPERT |
1664 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(fix_sub_duration_heartbeat) },
1665 "set this video output stream to be a heartbeat stream for "
1666 "fix_sub_duration, according to which subtitles should be split at "
1667 "random access points" },
1668
1669 /* audio options */
1670 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
1671 "set the number of audio frames to output", "number" },
1672 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
1673 "set audio quality (codec-specific)", "quality", },
1674 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
1675 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
1676 "set audio sampling rate (in Hz)", "rate" },
1677 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
1678 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
1679 "set number of audio channels", "channels" },
1680 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
1681 "disable audio" },
1682 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
1683 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
1684 "force audio codec ('copy' to copy stream)", "codec" },
1685 { "ab", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
1686 "audio bitrate (please use -b:a)", "bitrate" },
1687 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
1688 OPT_OUTPUT, { .func_arg = opt_old2new },
1689 "force audio tag/fourcc", "fourcc/tag" },
1690 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
1691 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
1692 "set sample format", "format" },
1693 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
1694 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_ch_layouts) },
1695 "set channel layout", "layout" },
1696 { "ch_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
1697 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_ch_layouts) },
1698 "set channel layout", "layout" },
1699 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
1700 "set audio filters", "filter_graph" },
1701 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
1702 "set the maximum number of channels to try to guess the channel layout" },
1703
1704 /* subtitle options */
1705 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
1706 "disable subtitle" },
1707 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
1708 "force subtitle codec ('copy' to copy stream)", "codec" },
1709 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
1710 , "force subtitle tag/fourcc", "fourcc/tag" },
1711 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
1712 "fix subtitles duration" },
1713 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
1714 "set canvas size (WxH or abbreviation)", "size" },
1715
1716 /* muxer options */
1717 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
1718 "set the maximum demux-decode delay", "seconds" },
1719 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
1720 "set the initial demux-decode delay", "seconds" },
1721 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
1722 "specify a file in which to print sdp information", "file" },
1723
1724 { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
1725 "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
1726 { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) },
1727 "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
1728 "two special values are defined - "
1729 "0 = use frame rate (video) or sample rate (audio),"
1730 "-1 = match source time base", "ratio" },
1731
1732 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
1733 "A comma-separated list of bitstream filters", "bitstream_filters" },
1734 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
1735 "deprecated", "audio bitstream_filters" },
1736 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
1737 "deprecated", "video bitstream_filters" },
1738
1739 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
1740 "set the audio options to the indicated preset", "preset" },
1741 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
1742 "set the video options to the indicated preset", "preset" },
1743 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
1744 "set the subtitle options to the indicated preset", "preset" },
1745 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
1746 "set options from indicated preset file", "filename" },
1747
1748 { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
1749 "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
1750 { "muxing_queue_data_threshold", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(muxing_queue_data_threshold) },
1751 "set the threshold after which max_muxing_queue_size is taken into account", "bytes" },
1752
1753 /* data codec support */
1754 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
1755 "force data codec ('copy' to copy stream)", "codec" },
1756 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
1757 "disable data" },
1758
1759 #if CONFIG_VAAPI
1760 { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
1761 "set VAAPI hardware device (DRM path or X11 display name)", "device" },
1762 #endif
1763
1764 #if CONFIG_QSV
1765 { "qsv_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_qsv_device },
1766 "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
1767 #endif
1768
1769 { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
1770 "initialise hardware device", "args" },
1771 { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
1772 "set hardware device used when filtering", "device" },
1773
1774 { NULL, },
1775 };
1776