1
2 /*
3 * ffmpeg option parsing
4 *
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 #include <stdint.h>
23
24 #include "ffmpeg.h"
25 #include "cmdutils.h"
26
27 #include "libavformat/avformat.h"
28
29 #include "libavcodec/avcodec.h"
30
31 #include "libavfilter/avfilter.h"
32
33 #include "libavutil/avassert.h"
34 #include "libavutil/avstring.h"
35 #include "libavutil/avutil.h"
36 #include "libavutil/channel_layout.h"
37 #include "libavutil/intreadwrite.h"
38 #include "libavutil/fifo.h"
39 #include "libavutil/mathematics.h"
40 #include "libavutil/opt.h"
41 #include "libavutil/parseutils.h"
42 #include "libavutil/pixdesc.h"
43 #include "libavutil/pixfmt.h"
44
45 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
46
47 #define SPECIFIER_OPT_FMT_str "%s"
48 #define SPECIFIER_OPT_FMT_i "%i"
49 #define SPECIFIER_OPT_FMT_i64 "%"PRId64
50 #define SPECIFIER_OPT_FMT_ui64 "%"PRIu64
51 #define SPECIFIER_OPT_FMT_f "%f"
52 #define SPECIFIER_OPT_FMT_dbl "%lf"
53
54 static const char *opt_name_codec_names[] = {"c", "codec", "acodec", "vcodec", "scodec", "dcodec", NULL};
55 static const char *opt_name_audio_channels[] = {"ac", NULL};
56 static const char *opt_name_audio_sample_rate[] = {"ar", NULL};
57 static const char *opt_name_frame_rates[] = {"r", NULL};
58 static const char *opt_name_frame_sizes[] = {"s", NULL};
59 static const char *opt_name_frame_pix_fmts[] = {"pix_fmt", NULL};
60 static const char *opt_name_ts_scale[] = {"itsscale", NULL};
61 static const char *opt_name_hwaccels[] = {"hwaccel", NULL};
62 static const char *opt_name_hwaccel_devices[] = {"hwaccel_device", NULL};
63 static const char *opt_name_hwaccel_output_formats[] = {"hwaccel_output_format", NULL};
64 static const char *opt_name_autorotate[] = {"autorotate", NULL};
65 static const char *opt_name_max_frames[] = {"frames", "aframes", "vframes", "dframes", NULL};
66 static const char *opt_name_bitstream_filters[] = {"bsf", "absf", "vbsf", NULL};
67 static const char *opt_name_codec_tags[] = {"tag", "atag", "vtag", "stag", NULL};
68 static const char *opt_name_sample_fmts[] = {"sample_fmt", NULL};
69 static const char *opt_name_qscale[] = {"q", "qscale", NULL};
70 static const char *opt_name_forced_key_frames[] = {"forced_key_frames", NULL};
71 static const char *opt_name_force_fps[] = {"force_fps", NULL};
72 static const char *opt_name_frame_aspect_ratios[] = {"aspect", NULL};
73 static const char *opt_name_rc_overrides[] = {"rc_override", NULL};
74 static const char *opt_name_intra_matrices[] = {"intra_matrix", NULL};
75 static const char *opt_name_inter_matrices[] = {"inter_matrix", NULL};
76 static const char *opt_name_chroma_intra_matrices[] = {"chroma_intra_matrix", NULL};
77 static const char *opt_name_top_field_first[] = {"top", NULL};
78 static const char *opt_name_presets[] = {"pre", "apre", "vpre", "spre", NULL};
79 static const char *opt_name_copy_initial_nonkeyframes[] = {"copyinkfr", NULL};
80 static const char *opt_name_copy_prior_start[] = {"copypriorss", NULL};
81 static const char *opt_name_filters[] = {"filter", "af", "vf", NULL};
82 static const char *opt_name_filter_scripts[] = {"filter_script", NULL};
83 static const char *opt_name_reinit_filters[] = {"reinit_filter", NULL};
84 static const char *opt_name_fix_sub_duration[] = {"fix_sub_duration", NULL};
85 static const char *opt_name_canvas_sizes[] = {"canvas_size", NULL};
86 static const char *opt_name_pass[] = {"pass", NULL};
87 static const char *opt_name_passlogfiles[] = {"passlogfile", NULL};
88 static const char *opt_name_max_muxing_queue_size[] = {"max_muxing_queue_size", NULL};
89 static const char *opt_name_guess_layout_max[] = {"guess_layout_max", NULL};
90 static const char *opt_name_apad[] = {"apad", NULL};
91 static const char *opt_name_discard[] = {"discard", NULL};
92 static const char *opt_name_disposition[] = {"disposition", NULL};
93 static const char *opt_name_time_bases[] = {"time_base", NULL};
94 static const char *opt_name_enc_time_bases[] = {"enc_time_base", NULL};
95
96 #define WARN_MULTIPLE_OPT_USAGE(name, type, so, st)\
97 {\
98 char namestr[128] = "";\
99 const char *spec = so->specifier && so->specifier[0] ? so->specifier : "";\
100 for (i = 0; opt_name_##name[i]; i++)\
101 av_strlcatf(namestr, sizeof(namestr), "-%s%s", opt_name_##name[i], opt_name_##name[i+1] ? (opt_name_##name[i+2] ? ", " : " or ") : "");\
102 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",\
103 namestr, st->index, opt_name_##name[0], spec[0] ? ":" : "", spec, so->u.type);\
104 }
105
106 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
107 {\
108 int i, ret, matches = 0;\
109 SpecifierOpt *so;\
110 for (i = 0; i < o->nb_ ## name; i++) {\
111 char *spec = o->name[i].specifier;\
112 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0) {\
113 outvar = o->name[i].u.type;\
114 so = &o->name[i];\
115 matches++;\
116 } else if (ret < 0)\
117 exit_program(1);\
118 }\
119 if (matches > 1)\
120 WARN_MULTIPLE_OPT_USAGE(name, type, so, st);\
121 }
122
123 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
124 {\
125 int i;\
126 for (i = 0; i < o->nb_ ## name; i++) {\
127 char *spec = o->name[i].specifier;\
128 if (!strcmp(spec, mediatype))\
129 outvar = o->name[i].u.type;\
130 }\
131 }
132
133 const HWAccel hwaccels[] = {
134 #if CONFIG_VIDEOTOOLBOX
135 { "videotoolbox", videotoolbox_init, HWACCEL_VIDEOTOOLBOX, AV_PIX_FMT_VIDEOTOOLBOX },
136 #endif
137 #if CONFIG_LIBMFX
138 { "qsv", qsv_init, HWACCEL_QSV, AV_PIX_FMT_QSV },
139 #endif
140 { 0 },
141 };
142 HWDevice *filter_hw_device;
143
144 char *vstats_filename;
145 char *sdp_filename;
146
147 float audio_drift_threshold = 0.1;
148 float dts_delta_threshold = 10;
149 float dts_error_threshold = 3600*30;
150
151 int audio_volume = 256;
152 int audio_sync_method = 0;
153 int video_sync_method = VSYNC_AUTO;
154 float frame_drop_threshold = 0;
155 int do_deinterlace = 0;
156 int do_benchmark = 0;
157 int do_benchmark_all = 0;
158 int do_hex_dump = 0;
159 int do_pkt_dump = 0;
160 int copy_ts = 0;
161 int start_at_zero = 0;
162 int copy_tb = -1;
163 int debug_ts = 0;
164 int exit_on_error = 0;
165 int abort_on_flags = 0;
166 int print_stats = -1;
167 int qp_hist = 0;
168 int stdin_interaction = 1;
169 int frame_bits_per_raw_sample = 0;
170 float max_error_rate = 2.0/3;
171 int filter_nbthreads = 0;
172 int filter_complex_nbthreads = 0;
173 int vstats_version = 2;
174
175
176 static int intra_only = 0;
177 static int file_overwrite = 0;
178 static int no_file_overwrite = 0;
179 static int do_psnr = 0;
180 static int input_sync;
181 static int input_stream_potentially_available = 0;
182 static int ignore_unknown_streams = 0;
183 static int copy_unknown_streams = 0;
184 static int find_stream_info = 1;
185
uninit_options(OptionsContext * o)186 static void uninit_options(OptionsContext *o)
187 {
188 const OptionDef *po = options;
189 int i;
190
191 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
192 while (po->name) {
193 void *dst = (uint8_t*)o + po->u.off;
194
195 if (po->flags & OPT_SPEC) {
196 SpecifierOpt **so = dst;
197 int i, *count = (int*)(so + 1);
198 for (i = 0; i < *count; i++) {
199 av_freep(&(*so)[i].specifier);
200 if (po->flags & OPT_STRING)
201 av_freep(&(*so)[i].u.str);
202 }
203 av_freep(so);
204 *count = 0;
205 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
206 av_freep(dst);
207 po++;
208 }
209
210 for (i = 0; i < o->nb_stream_maps; i++)
211 av_freep(&o->stream_maps[i].linklabel);
212 av_freep(&o->stream_maps);
213 av_freep(&o->audio_channel_maps);
214 av_freep(&o->streamid_map);
215 av_freep(&o->attachments);
216 }
217
init_options(OptionsContext * o)218 static void init_options(OptionsContext *o)
219 {
220 memset(o, 0, sizeof(*o));
221
222 o->stop_time = INT64_MAX;
223 o->mux_max_delay = 0.7;
224 o->start_time = AV_NOPTS_VALUE;
225 o->start_time_eof = AV_NOPTS_VALUE;
226 o->recording_time = INT64_MAX;
227 o->limit_filesize = UINT64_MAX;
228 o->chapters_input_file = INT_MAX;
229 o->accurate_seek = 1;
230 }
231
show_hwaccels(void * optctx,const char * opt,const char * arg)232 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
233 {
234 enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
235
236 printf("Hardware acceleration methods:\n");
237 while ((type = av_hwdevice_iterate_types(type)) !=
238 AV_HWDEVICE_TYPE_NONE)
239 printf("%s\n", av_hwdevice_get_type_name(type));
240 printf("\n");
241 return 0;
242 }
243
244 /* return a copy of the input with the stream specifiers removed from the keys */
strip_specifiers(AVDictionary * dict)245 static AVDictionary *strip_specifiers(AVDictionary *dict)
246 {
247 AVDictionaryEntry *e = NULL;
248 AVDictionary *ret = NULL;
249
250 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
251 char *p = strchr(e->key, ':');
252
253 if (p)
254 *p = 0;
255 av_dict_set(&ret, e->key, e->value, 0);
256 if (p)
257 *p = ':';
258 }
259 return ret;
260 }
261
opt_abort_on(void * optctx,const char * opt,const char * arg)262 static int opt_abort_on(void *optctx, const char *opt, const char *arg)
263 {
264 static const AVOption opts[] = {
265 { "abort_on" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
266 { "empty_output" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT }, .unit = "flags" },
267 { "empty_output_stream", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT_STREAM }, .unit = "flags" },
268 { NULL },
269 };
270 static const AVClass class = {
271 .class_name = "",
272 .item_name = av_default_item_name,
273 .option = opts,
274 .version = LIBAVUTIL_VERSION_INT,
275 };
276 const AVClass *pclass = &class;
277
278 return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
279 }
280
opt_sameq(void * optctx,const char * opt,const char * arg)281 static int opt_sameq(void *optctx, const char *opt, const char *arg)
282 {
283 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
284 "If you are looking for an option to preserve the quality (which is not "
285 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
286 opt, opt);
287 return AVERROR(EINVAL);
288 }
289
opt_video_channel(void * optctx,const char * opt,const char * arg)290 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
291 {
292 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
293 return opt_default(optctx, "channel", arg);
294 }
295
opt_video_standard(void * optctx,const char * opt,const char * arg)296 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
297 {
298 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
299 return opt_default(optctx, "standard", arg);
300 }
301
opt_audio_codec(void * optctx,const char * opt,const char * arg)302 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
303 {
304 OptionsContext *o = optctx;
305 return parse_option(o, "codec:a", arg, options);
306 }
307
opt_video_codec(void * optctx,const char * opt,const char * arg)308 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
309 {
310 OptionsContext *o = optctx;
311 return parse_option(o, "codec:v", arg, options);
312 }
313
opt_subtitle_codec(void * optctx,const char * opt,const char * arg)314 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
315 {
316 OptionsContext *o = optctx;
317 return parse_option(o, "codec:s", arg, options);
318 }
319
opt_data_codec(void * optctx,const char * opt,const char * arg)320 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
321 {
322 OptionsContext *o = optctx;
323 return parse_option(o, "codec:d", arg, options);
324 }
325
opt_map(void * optctx,const char * opt,const char * arg)326 static int opt_map(void *optctx, const char *opt, const char *arg)
327 {
328 OptionsContext *o = optctx;
329 StreamMap *m = NULL;
330 int i, negative = 0, file_idx, disabled = 0;
331 int sync_file_idx = -1, sync_stream_idx = 0;
332 char *p, *sync;
333 char *map;
334 char *allow_unused;
335
336 if (*arg == '-') {
337 negative = 1;
338 arg++;
339 }
340 map = av_strdup(arg);
341 if (!map)
342 return AVERROR(ENOMEM);
343
344 /* parse sync stream first, just pick first matching stream */
345 if (sync = strchr(map, ',')) {
346 *sync = 0;
347 sync_file_idx = strtol(sync + 1, &sync, 0);
348 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
349 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
350 exit_program(1);
351 }
352 if (*sync)
353 sync++;
354 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
355 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
356 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
357 sync_stream_idx = i;
358 break;
359 }
360 if (i == input_files[sync_file_idx]->nb_streams) {
361 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
362 "match any streams.\n", arg);
363 exit_program(1);
364 }
365 if (input_streams[input_files[sync_file_idx]->ist_index + sync_stream_idx]->user_set_discard == AVDISCARD_ALL) {
366 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s matches a disabled input "
367 "stream.\n", arg);
368 exit_program(1);
369 }
370 }
371
372
373 if (map[0] == '[') {
374 /* this mapping refers to lavfi output */
375 const char *c = map + 1;
376 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
377 m = &o->stream_maps[o->nb_stream_maps - 1];
378 m->linklabel = av_get_token(&c, "]");
379 if (!m->linklabel) {
380 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
381 exit_program(1);
382 }
383 } else {
384 if (allow_unused = strchr(map, '?'))
385 *allow_unused = 0;
386 file_idx = strtol(map, &p, 0);
387 if (file_idx >= nb_input_files || file_idx < 0) {
388 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
389 exit_program(1);
390 }
391 if (negative)
392 /* disable some already defined maps */
393 for (i = 0; i < o->nb_stream_maps; i++) {
394 m = &o->stream_maps[i];
395 if (file_idx == m->file_index &&
396 check_stream_specifier(input_files[m->file_index]->ctx,
397 input_files[m->file_index]->ctx->streams[m->stream_index],
398 *p == ':' ? p + 1 : p) > 0)
399 m->disabled = 1;
400 }
401 else
402 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
403 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
404 *p == ':' ? p + 1 : p) <= 0)
405 continue;
406 if (input_streams[input_files[file_idx]->ist_index + i]->user_set_discard == AVDISCARD_ALL) {
407 disabled = 1;
408 continue;
409 }
410 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
411 m = &o->stream_maps[o->nb_stream_maps - 1];
412
413 m->file_index = file_idx;
414 m->stream_index = i;
415
416 if (sync_file_idx >= 0) {
417 m->sync_file_index = sync_file_idx;
418 m->sync_stream_index = sync_stream_idx;
419 } else {
420 m->sync_file_index = file_idx;
421 m->sync_stream_index = i;
422 }
423 }
424 }
425
426 if (!m) {
427 if (allow_unused) {
428 av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
429 } else if (disabled) {
430 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches disabled streams.\n"
431 "To ignore this, add a trailing '?' to the map.\n", arg);
432 exit_program(1);
433 } else {
434 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
435 "To ignore this, add a trailing '?' to the map.\n", arg);
436 exit_program(1);
437 }
438 }
439
440 av_freep(&map);
441 return 0;
442 }
443
opt_attach(void * optctx,const char * opt,const char * arg)444 static int opt_attach(void *optctx, const char *opt, const char *arg)
445 {
446 OptionsContext *o = optctx;
447 GROW_ARRAY(o->attachments, o->nb_attachments);
448 o->attachments[o->nb_attachments - 1] = arg;
449 return 0;
450 }
451
opt_map_channel(void * optctx,const char * opt,const char * arg)452 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
453 {
454 OptionsContext *o = optctx;
455 int n;
456 AVStream *st;
457 AudioChannelMap *m;
458 char *allow_unused;
459 char *mapchan;
460 mapchan = av_strdup(arg);
461 if (!mapchan)
462 return AVERROR(ENOMEM);
463
464 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
465 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
466
467 /* muted channel syntax */
468 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
469 if ((n == 1 || n == 3) && m->channel_idx == -1) {
470 m->file_idx = m->stream_idx = -1;
471 if (n == 1)
472 m->ofile_idx = m->ostream_idx = -1;
473 av_free(mapchan);
474 return 0;
475 }
476
477 /* normal syntax */
478 n = sscanf(arg, "%d.%d.%d:%d.%d",
479 &m->file_idx, &m->stream_idx, &m->channel_idx,
480 &m->ofile_idx, &m->ostream_idx);
481
482 if (n != 3 && n != 5) {
483 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
484 "[file.stream.channel|-1][:syncfile:syncstream]\n");
485 exit_program(1);
486 }
487
488 if (n != 5) // only file.stream.channel specified
489 m->ofile_idx = m->ostream_idx = -1;
490
491 /* check input */
492 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
493 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
494 m->file_idx);
495 exit_program(1);
496 }
497 if (m->stream_idx < 0 ||
498 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
499 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
500 m->file_idx, m->stream_idx);
501 exit_program(1);
502 }
503 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
504 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
505 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
506 m->file_idx, m->stream_idx);
507 exit_program(1);
508 }
509 /* allow trailing ? to map_channel */
510 if (allow_unused = strchr(mapchan, '?'))
511 *allow_unused = 0;
512 if (m->channel_idx < 0 || m->channel_idx >= st->codecpar->channels ||
513 input_streams[input_files[m->file_idx]->ist_index + m->stream_idx]->user_set_discard == AVDISCARD_ALL) {
514 if (allow_unused) {
515 av_log(NULL, AV_LOG_VERBOSE, "mapchan: invalid audio channel #%d.%d.%d\n",
516 m->file_idx, m->stream_idx, m->channel_idx);
517 } else {
518 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n"
519 "To ignore this, add a trailing '?' to the map_channel.\n",
520 m->file_idx, m->stream_idx, m->channel_idx);
521 exit_program(1);
522 }
523
524 }
525 av_free(mapchan);
526 return 0;
527 }
528
opt_sdp_file(void * optctx,const char * opt,const char * arg)529 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
530 {
531 av_free(sdp_filename);
532 sdp_filename = av_strdup(arg);
533 return 0;
534 }
535
536 #if CONFIG_VAAPI
opt_vaapi_device(void * optctx,const char * opt,const char * arg)537 static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
538 {
539 const char *prefix = "vaapi:";
540 char *tmp;
541 int err;
542 tmp = av_asprintf("%s%s", prefix, arg);
543 if (!tmp)
544 return AVERROR(ENOMEM);
545 err = hw_device_init_from_string(tmp, NULL);
546 av_free(tmp);
547 return err;
548 }
549 #endif
550
opt_init_hw_device(void * optctx,const char * opt,const char * arg)551 static int opt_init_hw_device(void *optctx, const char *opt, const char *arg)
552 {
553 if (!strcmp(arg, "list")) {
554 enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
555 printf("Supported hardware device types:\n");
556 while ((type = av_hwdevice_iterate_types(type)) !=
557 AV_HWDEVICE_TYPE_NONE)
558 printf("%s\n", av_hwdevice_get_type_name(type));
559 printf("\n");
560 exit_program(0);
561 } else {
562 return hw_device_init_from_string(arg, NULL);
563 }
564 }
565
opt_filter_hw_device(void * optctx,const char * opt,const char * arg)566 static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
567 {
568 if (filter_hw_device) {
569 av_log(NULL, AV_LOG_ERROR, "Only one filter device can be used.\n");
570 return AVERROR(EINVAL);
571 }
572 filter_hw_device = hw_device_get_by_name(arg);
573 if (!filter_hw_device) {
574 av_log(NULL, AV_LOG_ERROR, "Invalid filter device %s.\n", arg);
575 return AVERROR(EINVAL);
576 }
577 return 0;
578 }
579
580 /**
581 * Parse a metadata specifier passed as 'arg' parameter.
582 * @param arg metadata string to parse
583 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
584 * @param index for type c/p, chapter/program index is written here
585 * @param stream_spec for type s, the stream specifier is written here
586 */
parse_meta_type(char * arg,char * type,int * index,const char ** stream_spec)587 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
588 {
589 if (*arg) {
590 *type = *arg;
591 switch (*arg) {
592 case 'g':
593 break;
594 case 's':
595 if (*(++arg) && *arg != ':') {
596 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
597 exit_program(1);
598 }
599 *stream_spec = *arg == ':' ? arg + 1 : "";
600 break;
601 case 'c':
602 case 'p':
603 if (*(++arg) == ':')
604 *index = strtol(++arg, NULL, 0);
605 break;
606 default:
607 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
608 exit_program(1);
609 }
610 } else
611 *type = 'g';
612 }
613
copy_metadata(char * outspec,char * inspec,AVFormatContext * oc,AVFormatContext * ic,OptionsContext * o)614 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
615 {
616 AVDictionary **meta_in = NULL;
617 AVDictionary **meta_out = NULL;
618 int i, ret = 0;
619 char type_in, type_out;
620 const char *istream_spec = NULL, *ostream_spec = NULL;
621 int idx_in = 0, idx_out = 0;
622
623 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
624 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
625
626 if (!ic) {
627 if (type_out == 'g' || !*outspec)
628 o->metadata_global_manual = 1;
629 if (type_out == 's' || !*outspec)
630 o->metadata_streams_manual = 1;
631 if (type_out == 'c' || !*outspec)
632 o->metadata_chapters_manual = 1;
633 return 0;
634 }
635
636 if (type_in == 'g' || type_out == 'g')
637 o->metadata_global_manual = 1;
638 if (type_in == 's' || type_out == 's')
639 o->metadata_streams_manual = 1;
640 if (type_in == 'c' || type_out == 'c')
641 o->metadata_chapters_manual = 1;
642
643 /* ic is NULL when just disabling automatic mappings */
644 if (!ic)
645 return 0;
646
647 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
648 if ((index) < 0 || (index) >= (nb_elems)) {\
649 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
650 (desc), (index));\
651 exit_program(1);\
652 }
653
654 #define SET_DICT(type, meta, context, index)\
655 switch (type) {\
656 case 'g':\
657 meta = &context->metadata;\
658 break;\
659 case 'c':\
660 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
661 meta = &context->chapters[index]->metadata;\
662 break;\
663 case 'p':\
664 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
665 meta = &context->programs[index]->metadata;\
666 break;\
667 case 's':\
668 break; /* handled separately below */ \
669 default: av_assert0(0);\
670 }\
671
672 SET_DICT(type_in, meta_in, ic, idx_in);
673 SET_DICT(type_out, meta_out, oc, idx_out);
674
675 /* for input streams choose first matching stream */
676 if (type_in == 's') {
677 for (i = 0; i < ic->nb_streams; i++) {
678 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
679 meta_in = &ic->streams[i]->metadata;
680 break;
681 } else if (ret < 0)
682 exit_program(1);
683 }
684 if (!meta_in) {
685 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
686 exit_program(1);
687 }
688 }
689
690 if (type_out == 's') {
691 for (i = 0; i < oc->nb_streams; i++) {
692 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
693 meta_out = &oc->streams[i]->metadata;
694 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
695 } else if (ret < 0)
696 exit_program(1);
697 }
698 } else
699 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
700
701 return 0;
702 }
703
opt_recording_timestamp(void * optctx,const char * opt,const char * arg)704 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
705 {
706 OptionsContext *o = optctx;
707 char buf[128];
708 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
709 struct tm time = *gmtime((time_t*)&recording_timestamp);
710 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
711 return -1;
712 parse_option(o, "metadata", buf, options);
713
714 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
715 "tag instead.\n", opt);
716 return 0;
717 }
718
find_codec_or_die(const char * name,enum AVMediaType type,int encoder)719 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
720 {
721 const AVCodecDescriptor *desc;
722 const char *codec_string = encoder ? "encoder" : "decoder";
723 AVCodec *codec;
724
725 codec = encoder ?
726 avcodec_find_encoder_by_name(name) :
727 avcodec_find_decoder_by_name(name);
728
729 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
730 codec = encoder ? avcodec_find_encoder(desc->id) :
731 avcodec_find_decoder(desc->id);
732 if (codec)
733 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
734 codec_string, codec->name, desc->name);
735 }
736
737 if (!codec) {
738 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
739 exit_program(1);
740 }
741 if (codec->type != type) {
742 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
743 exit_program(1);
744 }
745 return codec;
746 }
747
choose_decoder(OptionsContext * o,AVFormatContext * s,AVStream * st)748 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
749 {
750 char *codec_name = NULL;
751
752 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
753 if (codec_name) {
754 AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
755 st->codecpar->codec_id = codec->id;
756 return codec;
757 } else
758 return avcodec_find_decoder(st->codecpar->codec_id);
759 }
760
761 /* Add all the streams from the given input file to the global
762 * list of input streams. */
add_input_streams(OptionsContext * o,AVFormatContext * ic)763 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
764 {
765 int i, ret;
766
767 for (i = 0; i < ic->nb_streams; i++) {
768 AVStream *st = ic->streams[i];
769 AVCodecParameters *par = st->codecpar;
770 InputStream *ist = av_mallocz(sizeof(*ist));
771 char *framerate = NULL, *hwaccel_device = NULL;
772 const char *hwaccel = NULL;
773 char *hwaccel_output_format = NULL;
774 char *codec_tag = NULL;
775 char *next;
776 char *discard_str = NULL;
777 const AVClass *cc = avcodec_get_class();
778 const AVOption *discard_opt = av_opt_find(&cc, "skip_frame", NULL, 0, 0);
779
780 if (!ist)
781 exit_program(1);
782
783 GROW_ARRAY(input_streams, nb_input_streams);
784 input_streams[nb_input_streams - 1] = ist;
785
786 ist->st = st;
787 ist->file_index = nb_input_files;
788 ist->discard = 1;
789 st->discard = AVDISCARD_ALL;
790 ist->nb_samples = 0;
791 ist->min_pts = INT64_MAX;
792 ist->max_pts = INT64_MIN;
793
794 ist->ts_scale = 1.0;
795 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
796
797 ist->autorotate = 1;
798 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
799
800 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
801 if (codec_tag) {
802 uint32_t tag = strtol(codec_tag, &next, 0);
803 if (*next)
804 tag = AV_RL32(codec_tag);
805 st->codecpar->codec_tag = tag;
806 }
807
808 ist->dec = choose_decoder(o, ic, st);
809 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codecpar->codec_id, ic, st, ist->dec);
810
811 ist->reinit_filters = -1;
812 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
813
814 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
815 ist->user_set_discard = AVDISCARD_NONE;
816
817 if ((o->video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ||
818 (o->audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ||
819 (o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) ||
820 (o->data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA))
821 ist->user_set_discard = AVDISCARD_ALL;
822
823 if (discard_str && av_opt_eval_int(&cc, discard_opt, discard_str, &ist->user_set_discard) < 0) {
824 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
825 discard_str);
826 exit_program(1);
827 }
828
829 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
830
831 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
832 if (!ist->dec_ctx) {
833 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
834 exit_program(1);
835 }
836
837 ret = avcodec_parameters_to_context(ist->dec_ctx, par);
838 if (ret < 0) {
839 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
840 exit_program(1);
841 }
842
843 if (o->bitexact)
844 ist->dec_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
845
846 switch (par->codec_type) {
847 case AVMEDIA_TYPE_VIDEO:
848 if(!ist->dec)
849 ist->dec = avcodec_find_decoder(par->codec_id);
850 #if FF_API_LOWRES
851 if (st->codec->lowres) {
852 ist->dec_ctx->lowres = st->codec->lowres;
853 ist->dec_ctx->width = st->codec->width;
854 ist->dec_ctx->height = st->codec->height;
855 ist->dec_ctx->coded_width = st->codec->coded_width;
856 ist->dec_ctx->coded_height = st->codec->coded_height;
857 }
858 #endif
859
860 // avformat_find_stream_info() doesn't set this for us anymore.
861 ist->dec_ctx->framerate = st->avg_frame_rate;
862
863 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
864 if (framerate && av_parse_video_rate(&ist->framerate,
865 framerate) < 0) {
866 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
867 framerate);
868 exit_program(1);
869 }
870
871 ist->top_field_first = -1;
872 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
873
874 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
875 MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
876 hwaccel_output_format, ic, st);
877
878 if (!hwaccel_output_format && hwaccel && !strcmp(hwaccel, "cuvid")) {
879 av_log(NULL, AV_LOG_WARNING,
880 "WARNING: defaulting hwaccel_output_format to cuda for compatibility "
881 "with old commandlines. This behaviour is DEPRECATED and will be removed "
882 "in the future. Please explicitly set \"-hwaccel_output_format cuda\".\n");
883 ist->hwaccel_output_format = AV_PIX_FMT_CUDA;
884 } else if (hwaccel_output_format) {
885 ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
886 if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
887 av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
888 "format: %s", hwaccel_output_format);
889 }
890 } else {
891 ist->hwaccel_output_format = AV_PIX_FMT_NONE;
892 }
893
894 if (hwaccel) {
895 // The NVDEC hwaccels use a CUDA device, so remap the name here.
896 if (!strcmp(hwaccel, "nvdec") || !strcmp(hwaccel, "cuvid"))
897 hwaccel = "cuda";
898
899 if (!strcmp(hwaccel, "none"))
900 ist->hwaccel_id = HWACCEL_NONE;
901 else if (!strcmp(hwaccel, "auto"))
902 ist->hwaccel_id = HWACCEL_AUTO;
903 else {
904 enum AVHWDeviceType type;
905 int i;
906 for (i = 0; hwaccels[i].name; i++) {
907 if (!strcmp(hwaccels[i].name, hwaccel)) {
908 ist->hwaccel_id = hwaccels[i].id;
909 break;
910 }
911 }
912
913 if (!ist->hwaccel_id) {
914 type = av_hwdevice_find_type_by_name(hwaccel);
915 if (type != AV_HWDEVICE_TYPE_NONE) {
916 ist->hwaccel_id = HWACCEL_GENERIC;
917 ist->hwaccel_device_type = type;
918 }
919 }
920
921 if (!ist->hwaccel_id) {
922 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
923 hwaccel);
924 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
925 type = AV_HWDEVICE_TYPE_NONE;
926 while ((type = av_hwdevice_iterate_types(type)) !=
927 AV_HWDEVICE_TYPE_NONE)
928 av_log(NULL, AV_LOG_FATAL, "%s ",
929 av_hwdevice_get_type_name(type));
930 av_log(NULL, AV_LOG_FATAL, "\n");
931 exit_program(1);
932 }
933 }
934 }
935
936 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
937 if (hwaccel_device) {
938 ist->hwaccel_device = av_strdup(hwaccel_device);
939 if (!ist->hwaccel_device)
940 exit_program(1);
941 }
942
943 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
944
945 break;
946 case AVMEDIA_TYPE_AUDIO:
947 ist->guess_layout_max = INT_MAX;
948 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
949 guess_input_channel_layout(ist);
950 break;
951 case AVMEDIA_TYPE_DATA:
952 case AVMEDIA_TYPE_SUBTITLE: {
953 char *canvas_size = NULL;
954 if(!ist->dec)
955 ist->dec = avcodec_find_decoder(par->codec_id);
956 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
957 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
958 if (canvas_size &&
959 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
960 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
961 exit_program(1);
962 }
963 break;
964 }
965 case AVMEDIA_TYPE_ATTACHMENT:
966 case AVMEDIA_TYPE_UNKNOWN:
967 break;
968 default:
969 abort();
970 }
971
972 ret = avcodec_parameters_from_context(par, ist->dec_ctx);
973 if (ret < 0) {
974 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
975 exit_program(1);
976 }
977 }
978 }
979
assert_file_overwrite(const char * filename)980 static void assert_file_overwrite(const char *filename)
981 {
982 const char *proto_name = avio_find_protocol_name(filename);
983
984 if (file_overwrite && no_file_overwrite) {
985 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
986 exit_program(1);
987 }
988
989 if (!file_overwrite) {
990 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
991 if (stdin_interaction && !no_file_overwrite) {
992 fprintf(stderr,"File '%s' already exists. Overwrite? [y/N] ", filename);
993 fflush(stderr);
994 term_exit();
995 signal(SIGINT, SIG_DFL);
996 if (!read_yesno()) {
997 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
998 exit_program(1);
999 }
1000 term_init();
1001 }
1002 else {
1003 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
1004 exit_program(1);
1005 }
1006 }
1007 }
1008
1009 if (proto_name && !strcmp(proto_name, "file")) {
1010 for (int i = 0; i < nb_input_files; i++) {
1011 InputFile *file = input_files[i];
1012 if (file->ctx->iformat->flags & AVFMT_NOFILE)
1013 continue;
1014 if (!strcmp(filename, file->ctx->url)) {
1015 av_log(NULL, AV_LOG_FATAL, "Output %s same as Input #%d - exiting\n", filename, i);
1016 av_log(NULL, AV_LOG_WARNING, "FFmpeg cannot edit existing files in-place.\n");
1017 exit_program(1);
1018 }
1019 }
1020 }
1021 }
1022
dump_attachment(AVStream * st,const char * filename)1023 static void dump_attachment(AVStream *st, const char *filename)
1024 {
1025 int ret;
1026 AVIOContext *out = NULL;
1027 AVDictionaryEntry *e;
1028
1029 if (!st->codecpar->extradata_size) {
1030 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
1031 nb_input_files - 1, st->index);
1032 return;
1033 }
1034 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
1035 filename = e->value;
1036 if (!*filename) {
1037 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
1038 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
1039 exit_program(1);
1040 }
1041
1042 assert_file_overwrite(filename);
1043
1044 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
1045 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
1046 filename);
1047 exit_program(1);
1048 }
1049
1050 avio_write(out, st->codecpar->extradata, st->codecpar->extradata_size);
1051 avio_flush(out);
1052 avio_close(out);
1053 }
1054
open_input_file(OptionsContext * o,const char * filename)1055 static int open_input_file(OptionsContext *o, const char *filename)
1056 {
1057 InputFile *f;
1058 AVFormatContext *ic;
1059 AVInputFormat *file_iformat = NULL;
1060 int err, i, ret;
1061 int64_t timestamp;
1062 AVDictionary *unused_opts = NULL;
1063 AVDictionaryEntry *e = NULL;
1064 char * video_codec_name = NULL;
1065 char * audio_codec_name = NULL;
1066 char *subtitle_codec_name = NULL;
1067 char * data_codec_name = NULL;
1068 int scan_all_pmts_set = 0;
1069
1070 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1071 o->stop_time = INT64_MAX;
1072 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1073 }
1074
1075 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1076 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1077 if (o->stop_time <= start_time) {
1078 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1079 exit_program(1);
1080 } else {
1081 o->recording_time = o->stop_time - start_time;
1082 }
1083 }
1084
1085 if (o->format) {
1086 if (!(file_iformat = av_find_input_format(o->format))) {
1087 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
1088 exit_program(1);
1089 }
1090 }
1091
1092 if (!strcmp(filename, "-"))
1093 filename = "pipe:";
1094
1095 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
1096 strcmp(filename, "/dev/stdin");
1097
1098 /* get default parameters from command line */
1099 ic = avformat_alloc_context();
1100 if (!ic) {
1101 print_error(filename, AVERROR(ENOMEM));
1102 exit_program(1);
1103 }
1104 if (o->nb_audio_sample_rate) {
1105 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
1106 }
1107 if (o->nb_audio_channels) {
1108 /* because we set audio_channels based on both the "ac" and
1109 * "channel_layout" options, we need to check that the specified
1110 * demuxer actually has the "channels" option before setting it */
1111 if (file_iformat && file_iformat->priv_class &&
1112 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
1113 AV_OPT_SEARCH_FAKE_OBJ)) {
1114 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
1115 }
1116 }
1117 if (o->nb_frame_rates) {
1118 /* set the format-level framerate option;
1119 * this is important for video grabbers, e.g. x11 */
1120 if (file_iformat && file_iformat->priv_class &&
1121 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
1122 AV_OPT_SEARCH_FAKE_OBJ)) {
1123 av_dict_set(&o->g->format_opts, "framerate",
1124 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
1125 }
1126 }
1127 if (o->nb_frame_sizes) {
1128 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
1129 }
1130 if (o->nb_frame_pix_fmts)
1131 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
1132
1133 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
1134 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
1135 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
1136 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
1137
1138 if (video_codec_name)
1139 ic->video_codec = find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
1140 if (audio_codec_name)
1141 ic->audio_codec = find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
1142 if (subtitle_codec_name)
1143 ic->subtitle_codec = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
1144 if (data_codec_name)
1145 ic->data_codec = find_codec_or_die(data_codec_name , AVMEDIA_TYPE_DATA , 0);
1146
1147 ic->video_codec_id = video_codec_name ? ic->video_codec->id : AV_CODEC_ID_NONE;
1148 ic->audio_codec_id = audio_codec_name ? ic->audio_codec->id : AV_CODEC_ID_NONE;
1149 ic->subtitle_codec_id = subtitle_codec_name ? ic->subtitle_codec->id : AV_CODEC_ID_NONE;
1150 ic->data_codec_id = data_codec_name ? ic->data_codec->id : AV_CODEC_ID_NONE;
1151
1152 ic->flags |= AVFMT_FLAG_NONBLOCK;
1153 if (o->bitexact)
1154 ic->flags |= AVFMT_FLAG_BITEXACT;
1155 ic->interrupt_callback = int_cb;
1156
1157 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
1158 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
1159 scan_all_pmts_set = 1;
1160 }
1161 /* open the input file with generic avformat function */
1162 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
1163 if (err < 0) {
1164 print_error(filename, err);
1165 if (err == AVERROR_PROTOCOL_NOT_FOUND)
1166 av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
1167 exit_program(1);
1168 }
1169 if (scan_all_pmts_set)
1170 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
1171 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
1172 assert_avoptions(o->g->format_opts);
1173
1174 /* apply forced codec ids */
1175 for (i = 0; i < ic->nb_streams; i++)
1176 choose_decoder(o, ic, ic->streams[i]);
1177
1178 if (find_stream_info) {
1179 AVDictionary **opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
1180 int orig_nb_streams = ic->nb_streams;
1181
1182 /* If not enough info to get the stream parameters, we decode the
1183 first frames to get it. (used in mpeg case for example) */
1184 ret = avformat_find_stream_info(ic, opts);
1185
1186 for (i = 0; i < orig_nb_streams; i++)
1187 av_dict_free(&opts[i]);
1188 av_freep(&opts);
1189
1190 if (ret < 0) {
1191 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1192 if (ic->nb_streams == 0) {
1193 avformat_close_input(&ic);
1194 exit_program(1);
1195 }
1196 }
1197 }
1198
1199 if (o->start_time != AV_NOPTS_VALUE && o->start_time_eof != AV_NOPTS_VALUE) {
1200 av_log(NULL, AV_LOG_WARNING, "Cannot use -ss and -sseof both, using -ss for %s\n", filename);
1201 o->start_time_eof = AV_NOPTS_VALUE;
1202 }
1203
1204 if (o->start_time_eof != AV_NOPTS_VALUE) {
1205 if (o->start_time_eof >= 0) {
1206 av_log(NULL, AV_LOG_ERROR, "-sseof value must be negative; aborting\n");
1207 exit_program(1);
1208 }
1209 if (ic->duration > 0) {
1210 o->start_time = o->start_time_eof + ic->duration;
1211 if (o->start_time < 0) {
1212 av_log(NULL, AV_LOG_WARNING, "-sseof value seeks to before start of file %s; ignored\n", filename);
1213 o->start_time = AV_NOPTS_VALUE;
1214 }
1215 } else
1216 av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1217 }
1218 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1219 /* add the stream start time */
1220 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1221 timestamp += ic->start_time;
1222
1223 /* if seeking requested, we execute it */
1224 if (o->start_time != AV_NOPTS_VALUE) {
1225 int64_t seek_timestamp = timestamp;
1226
1227 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1228 int dts_heuristic = 0;
1229 for (i=0; i<ic->nb_streams; i++) {
1230 const AVCodecParameters *par = ic->streams[i]->codecpar;
1231 if (par->video_delay) {
1232 dts_heuristic = 1;
1233 break;
1234 }
1235 }
1236 if (dts_heuristic) {
1237 seek_timestamp -= 3*AV_TIME_BASE / 23;
1238 }
1239 }
1240 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1241 if (ret < 0) {
1242 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1243 filename, (double)timestamp / AV_TIME_BASE);
1244 }
1245 }
1246
1247 /* update the current parameters so that they match the one of the input stream */
1248 add_input_streams(o, ic);
1249
1250 /* dump the file content */
1251 av_dump_format(ic, nb_input_files, filename, 0);
1252
1253 GROW_ARRAY(input_files, nb_input_files);
1254 f = av_mallocz(sizeof(*f));
1255 if (!f)
1256 exit_program(1);
1257 input_files[nb_input_files - 1] = f;
1258
1259 f->ctx = ic;
1260 f->ist_index = nb_input_streams - ic->nb_streams;
1261 f->start_time = o->start_time;
1262 f->recording_time = o->recording_time;
1263 f->input_ts_offset = o->input_ts_offset;
1264 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1265 f->nb_streams = ic->nb_streams;
1266 f->rate_emu = o->rate_emu;
1267 f->accurate_seek = o->accurate_seek;
1268 f->loop = o->loop;
1269 f->duration = 0;
1270 f->time_base = (AVRational){ 1, 1 };
1271 #if HAVE_THREADS
1272 f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1273 #endif
1274
1275 /* check if all codec options have been used */
1276 unused_opts = strip_specifiers(o->g->codec_opts);
1277 for (i = f->ist_index; i < nb_input_streams; i++) {
1278 e = NULL;
1279 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1280 AV_DICT_IGNORE_SUFFIX)))
1281 av_dict_set(&unused_opts, e->key, NULL, 0);
1282 }
1283
1284 e = NULL;
1285 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1286 const AVClass *class = avcodec_get_class();
1287 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1288 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1289 const AVClass *fclass = avformat_get_class();
1290 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1291 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1292 if (!option || foption)
1293 continue;
1294
1295
1296 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1297 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1298 "input file #%d (%s) is not a decoding option.\n", e->key,
1299 option->help ? option->help : "", nb_input_files - 1,
1300 filename);
1301 exit_program(1);
1302 }
1303
1304 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1305 "input file #%d (%s) has not been used for any stream. The most "
1306 "likely reason is either wrong type (e.g. a video option with "
1307 "no video streams) or that it is a private option of some decoder "
1308 "which was not actually used for any stream.\n", e->key,
1309 option->help ? option->help : "", nb_input_files - 1, filename);
1310 }
1311 av_dict_free(&unused_opts);
1312
1313 for (i = 0; i < o->nb_dump_attachment; i++) {
1314 int j;
1315
1316 for (j = 0; j < ic->nb_streams; j++) {
1317 AVStream *st = ic->streams[j];
1318
1319 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1320 dump_attachment(st, o->dump_attachment[i].u.str);
1321 }
1322 }
1323
1324 input_stream_potentially_available = 1;
1325
1326 return 0;
1327 }
1328
get_line(AVIOContext * s)1329 static uint8_t *get_line(AVIOContext *s)
1330 {
1331 AVIOContext *line;
1332 uint8_t *buf;
1333 char c;
1334
1335 if (avio_open_dyn_buf(&line) < 0) {
1336 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1337 exit_program(1);
1338 }
1339
1340 while ((c = avio_r8(s)) && c != '\n')
1341 avio_w8(line, c);
1342 avio_w8(line, 0);
1343 avio_close_dyn_buf(line, &buf);
1344
1345 return buf;
1346 }
1347
get_preset_file_2(const char * preset_name,const char * codec_name,AVIOContext ** s)1348 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1349 {
1350 int i, ret = -1;
1351 char filename[1000];
1352 const char *base[3] = { getenv("AVCONV_DATADIR"),
1353 getenv("HOME"),
1354 AVCONV_DATADIR,
1355 };
1356
1357 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1358 if (!base[i])
1359 continue;
1360 if (codec_name) {
1361 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1362 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1363 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1364 }
1365 if (ret < 0) {
1366 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1367 i != 1 ? "" : "/.avconv", preset_name);
1368 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1369 }
1370 }
1371 return ret;
1372 }
1373
choose_encoder(OptionsContext * o,AVFormatContext * s,OutputStream * ost)1374 static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1375 {
1376 enum AVMediaType type = ost->st->codecpar->codec_type;
1377 char *codec_name = NULL;
1378
1379 if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1380 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1381 if (!codec_name) {
1382 ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->url,
1383 NULL, ost->st->codecpar->codec_type);
1384 ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
1385 if (!ost->enc) {
1386 av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1387 "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1388 "probably disabled. Please choose an encoder manually.\n",
1389 ost->file_index, ost->index, s->oformat->name,
1390 avcodec_get_name(ost->st->codecpar->codec_id));
1391 return AVERROR_ENCODER_NOT_FOUND;
1392 }
1393 } else if (!strcmp(codec_name, "copy"))
1394 ost->stream_copy = 1;
1395 else {
1396 ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
1397 ost->st->codecpar->codec_id = ost->enc->id;
1398 }
1399 ost->encoding_needed = !ost->stream_copy;
1400 } else {
1401 /* no encoding supported for other media types */
1402 ost->stream_copy = 1;
1403 ost->encoding_needed = 0;
1404 }
1405
1406 return 0;
1407 }
1408
new_output_stream(OptionsContext * o,AVFormatContext * oc,enum AVMediaType type,int source_index)1409 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1410 {
1411 OutputStream *ost;
1412 AVStream *st = avformat_new_stream(oc, NULL);
1413 int idx = oc->nb_streams - 1, ret = 0;
1414 const char *bsfs = NULL, *time_base = NULL;
1415 char *next, *codec_tag = NULL;
1416 double qscale = -1;
1417 int i;
1418
1419 if (!st) {
1420 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1421 exit_program(1);
1422 }
1423
1424 if (oc->nb_streams - 1 < o->nb_streamid_map)
1425 st->id = o->streamid_map[oc->nb_streams - 1];
1426
1427 GROW_ARRAY(output_streams, nb_output_streams);
1428 if (!(ost = av_mallocz(sizeof(*ost))))
1429 exit_program(1);
1430 output_streams[nb_output_streams - 1] = ost;
1431
1432 ost->file_index = nb_output_files - 1;
1433 ost->index = idx;
1434 ost->st = st;
1435 ost->forced_kf_ref_pts = AV_NOPTS_VALUE;
1436 st->codecpar->codec_type = type;
1437
1438 ret = choose_encoder(o, oc, ost);
1439 if (ret < 0) {
1440 av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1441 "%d:%d\n", ost->file_index, ost->index);
1442 exit_program(1);
1443 }
1444
1445 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1446 if (!ost->enc_ctx) {
1447 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1448 exit_program(1);
1449 }
1450 ost->enc_ctx->codec_type = type;
1451
1452 ost->ref_par = avcodec_parameters_alloc();
1453 if (!ost->ref_par) {
1454 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n");
1455 exit_program(1);
1456 }
1457
1458 if (ost->enc) {
1459 AVIOContext *s = NULL;
1460 char *buf = NULL, *arg = NULL, *preset = NULL;
1461
1462 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1463
1464 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1465 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1466 do {
1467 buf = get_line(s);
1468 if (!buf[0] || buf[0] == '#') {
1469 av_free(buf);
1470 continue;
1471 }
1472 if (!(arg = strchr(buf, '='))) {
1473 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1474 exit_program(1);
1475 }
1476 *arg++ = 0;
1477 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1478 av_free(buf);
1479 } while (!s->eof_reached);
1480 avio_closep(&s);
1481 }
1482 if (ret) {
1483 av_log(NULL, AV_LOG_FATAL,
1484 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1485 preset, ost->file_index, ost->index);
1486 exit_program(1);
1487 }
1488 } else {
1489 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1490 }
1491
1492
1493 if (o->bitexact)
1494 ost->enc_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
1495
1496 MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1497 if (time_base) {
1498 AVRational q;
1499 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1500 q.num <= 0 || q.den <= 0) {
1501 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1502 exit_program(1);
1503 }
1504 st->time_base = q;
1505 }
1506
1507 MATCH_PER_STREAM_OPT(enc_time_bases, str, time_base, oc, st);
1508 if (time_base) {
1509 AVRational q;
1510 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1511 q.den <= 0) {
1512 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1513 exit_program(1);
1514 }
1515 ost->enc_timebase = q;
1516 }
1517
1518 ost->max_frames = INT64_MAX;
1519 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1520 for (i = 0; i<o->nb_max_frames; i++) {
1521 char *p = o->max_frames[i].specifier;
1522 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1523 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1524 break;
1525 }
1526 }
1527
1528 ost->copy_prior_start = -1;
1529 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1530
1531 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1532 if (bsfs && *bsfs) {
1533 ret = av_bsf_list_parse_str(bsfs, &ost->bsf_ctx);
1534 if (ret < 0) {
1535 av_log(NULL, AV_LOG_ERROR, "Error parsing bitstream filter sequence '%s': %s\n", bsfs, av_err2str(ret));
1536 exit_program(1);
1537 }
1538 }
1539
1540 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1541 if (codec_tag) {
1542 uint32_t tag = strtol(codec_tag, &next, 0);
1543 if (*next)
1544 tag = AV_RL32(codec_tag);
1545 ost->st->codecpar->codec_tag =
1546 ost->enc_ctx->codec_tag = tag;
1547 }
1548
1549 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1550 if (qscale >= 0) {
1551 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1552 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1553 }
1554
1555 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1556 ost->disposition = av_strdup(ost->disposition);
1557
1558 ost->max_muxing_queue_size = 128;
1559 MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1560 ost->max_muxing_queue_size *= sizeof(AVPacket);
1561
1562 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1563 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1564
1565 av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1566
1567 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1568 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1569 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1570
1571 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1572
1573 ost->source_index = source_index;
1574 if (source_index >= 0) {
1575 ost->sync_ist = input_streams[source_index];
1576 input_streams[source_index]->discard = 0;
1577 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1578 }
1579 ost->last_mux_dts = AV_NOPTS_VALUE;
1580
1581 ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1582 if (!ost->muxing_queue)
1583 exit_program(1);
1584
1585 return ost;
1586 }
1587
parse_matrix_coeffs(uint16_t * dest,const char * str)1588 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1589 {
1590 int i;
1591 const char *p = str;
1592 for (i = 0;; i++) {
1593 dest[i] = atoi(p);
1594 if (i == 63)
1595 break;
1596 p = strchr(p, ',');
1597 if (!p) {
1598 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1599 exit_program(1);
1600 }
1601 p++;
1602 }
1603 }
1604
1605 /* read file contents into a string */
read_file(const char * filename)1606 static uint8_t *read_file(const char *filename)
1607 {
1608 AVIOContext *pb = NULL;
1609 AVIOContext *dyn_buf = NULL;
1610 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1611 uint8_t buf[1024], *str;
1612
1613 if (ret < 0) {
1614 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1615 return NULL;
1616 }
1617
1618 ret = avio_open_dyn_buf(&dyn_buf);
1619 if (ret < 0) {
1620 avio_closep(&pb);
1621 return NULL;
1622 }
1623 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1624 avio_write(dyn_buf, buf, ret);
1625 avio_w8(dyn_buf, 0);
1626 avio_closep(&pb);
1627
1628 ret = avio_close_dyn_buf(dyn_buf, &str);
1629 if (ret < 0)
1630 return NULL;
1631 return str;
1632 }
1633
get_ost_filters(OptionsContext * o,AVFormatContext * oc,OutputStream * ost)1634 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1635 OutputStream *ost)
1636 {
1637 AVStream *st = ost->st;
1638
1639 if (ost->filters_script && ost->filters) {
1640 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1641 "output stream #%d:%d.\n", nb_output_files, st->index);
1642 exit_program(1);
1643 }
1644
1645 if (ost->filters_script)
1646 return read_file(ost->filters_script);
1647 else if (ost->filters)
1648 return av_strdup(ost->filters);
1649
1650 return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1651 "null" : "anull");
1652 }
1653
check_streamcopy_filters(OptionsContext * o,AVFormatContext * oc,const OutputStream * ost,enum AVMediaType type)1654 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1655 const OutputStream *ost, enum AVMediaType type)
1656 {
1657 if (ost->filters_script || ost->filters) {
1658 av_log(NULL, AV_LOG_ERROR,
1659 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1660 "Filtering and streamcopy cannot be used together.\n",
1661 ost->filters ? "Filtergraph" : "Filtergraph script",
1662 ost->filters ? ost->filters : ost->filters_script,
1663 av_get_media_type_string(type), ost->file_index, ost->index);
1664 exit_program(1);
1665 }
1666 }
1667
new_video_stream(OptionsContext * o,AVFormatContext * oc,int source_index)1668 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1669 {
1670 AVStream *st;
1671 OutputStream *ost;
1672 AVCodecContext *video_enc;
1673 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1674
1675 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1676 st = ost->st;
1677 video_enc = ost->enc_ctx;
1678
1679 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1680 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1681 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1682 exit_program(1);
1683 }
1684 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1685 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1686
1687 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1688 if (frame_aspect_ratio) {
1689 AVRational q;
1690 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1691 q.num <= 0 || q.den <= 0) {
1692 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1693 exit_program(1);
1694 }
1695 ost->frame_aspect_ratio = q;
1696 }
1697
1698 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1699 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1700
1701 if (!ost->stream_copy) {
1702 const char *p = NULL;
1703 char *frame_size = NULL;
1704 char *frame_pix_fmt = NULL;
1705 char *intra_matrix = NULL, *inter_matrix = NULL;
1706 char *chroma_intra_matrix = NULL;
1707 int do_pass = 0;
1708 int i;
1709
1710 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1711 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1712 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1713 exit_program(1);
1714 }
1715
1716 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1717 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1718 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1719 ost->keep_pix_fmt = 1;
1720 if (!*++frame_pix_fmt)
1721 frame_pix_fmt = NULL;
1722 }
1723 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1724 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1725 exit_program(1);
1726 }
1727 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1728
1729 if (intra_only)
1730 video_enc->gop_size = 0;
1731 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1732 if (intra_matrix) {
1733 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1734 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1735 exit_program(1);
1736 }
1737 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1738 }
1739 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1740 if (chroma_intra_matrix) {
1741 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1742 if (!p) {
1743 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1744 exit_program(1);
1745 }
1746 video_enc->chroma_intra_matrix = p;
1747 parse_matrix_coeffs(p, chroma_intra_matrix);
1748 }
1749 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1750 if (inter_matrix) {
1751 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1752 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1753 exit_program(1);
1754 }
1755 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1756 }
1757
1758 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1759 for (i = 0; p; i++) {
1760 int start, end, q;
1761 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1762 if (e != 3) {
1763 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1764 exit_program(1);
1765 }
1766 video_enc->rc_override =
1767 av_realloc_array(video_enc->rc_override,
1768 i + 1, sizeof(RcOverride));
1769 if (!video_enc->rc_override) {
1770 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1771 exit_program(1);
1772 }
1773 video_enc->rc_override[i].start_frame = start;
1774 video_enc->rc_override[i].end_frame = end;
1775 if (q > 0) {
1776 video_enc->rc_override[i].qscale = q;
1777 video_enc->rc_override[i].quality_factor = 1.0;
1778 }
1779 else {
1780 video_enc->rc_override[i].qscale = 0;
1781 video_enc->rc_override[i].quality_factor = -q/100.0;
1782 }
1783 p = strchr(p, '/');
1784 if (p) p++;
1785 }
1786 video_enc->rc_override_count = i;
1787
1788 if (do_psnr)
1789 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1790
1791 /* two pass mode */
1792 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1793 if (do_pass) {
1794 if (do_pass & 1) {
1795 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1796 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1797 }
1798 if (do_pass & 2) {
1799 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1800 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1801 }
1802 }
1803
1804 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1805 if (ost->logfile_prefix &&
1806 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1807 exit_program(1);
1808
1809 if (do_pass) {
1810 char logfilename[1024];
1811 FILE *f;
1812
1813 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1814 ost->logfile_prefix ? ost->logfile_prefix :
1815 DEFAULT_PASS_LOGFILENAME_PREFIX,
1816 i);
1817 if (!strcmp(ost->enc->name, "libx264")) {
1818 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1819 } else {
1820 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1821 char *logbuffer = read_file(logfilename);
1822
1823 if (!logbuffer) {
1824 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1825 logfilename);
1826 exit_program(1);
1827 }
1828 video_enc->stats_in = logbuffer;
1829 }
1830 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1831 f = av_fopen_utf8(logfilename, "wb");
1832 if (!f) {
1833 av_log(NULL, AV_LOG_FATAL,
1834 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1835 logfilename, strerror(errno));
1836 exit_program(1);
1837 }
1838 ost->logfile = f;
1839 }
1840 }
1841 }
1842
1843 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1844 if (ost->forced_keyframes)
1845 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1846
1847 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1848
1849 ost->top_field_first = -1;
1850 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1851
1852
1853 ost->avfilter = get_ost_filters(o, oc, ost);
1854 if (!ost->avfilter)
1855 exit_program(1);
1856 } else {
1857 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1858 }
1859
1860 if (ost->stream_copy)
1861 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1862
1863 return ost;
1864 }
1865
new_audio_stream(OptionsContext * o,AVFormatContext * oc,int source_index)1866 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1867 {
1868 int n;
1869 AVStream *st;
1870 OutputStream *ost;
1871 AVCodecContext *audio_enc;
1872
1873 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1874 st = ost->st;
1875
1876 audio_enc = ost->enc_ctx;
1877 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1878
1879 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1880 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1881
1882 if (!ost->stream_copy) {
1883 char *sample_fmt = NULL;
1884
1885 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1886
1887 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1888 if (sample_fmt &&
1889 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1890 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1891 exit_program(1);
1892 }
1893
1894 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1895
1896 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1897 ost->apad = av_strdup(ost->apad);
1898
1899 ost->avfilter = get_ost_filters(o, oc, ost);
1900 if (!ost->avfilter)
1901 exit_program(1);
1902
1903 /* check for channel mapping for this audio stream */
1904 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1905 AudioChannelMap *map = &o->audio_channel_maps[n];
1906 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1907 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1908 InputStream *ist;
1909
1910 if (map->channel_idx == -1) {
1911 ist = NULL;
1912 } else if (ost->source_index < 0) {
1913 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1914 ost->file_index, ost->st->index);
1915 continue;
1916 } else {
1917 ist = input_streams[ost->source_index];
1918 }
1919
1920 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1921 if (av_reallocp_array(&ost->audio_channels_map,
1922 ost->audio_channels_mapped + 1,
1923 sizeof(*ost->audio_channels_map)
1924 ) < 0 )
1925 exit_program(1);
1926
1927 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1928 }
1929 }
1930 }
1931 }
1932
1933 if (ost->stream_copy)
1934 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1935
1936 return ost;
1937 }
1938
new_data_stream(OptionsContext * o,AVFormatContext * oc,int source_index)1939 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1940 {
1941 OutputStream *ost;
1942
1943 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1944 if (!ost->stream_copy) {
1945 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1946 exit_program(1);
1947 }
1948
1949 return ost;
1950 }
1951
new_unknown_stream(OptionsContext * o,AVFormatContext * oc,int source_index)1952 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1953 {
1954 OutputStream *ost;
1955
1956 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1957 if (!ost->stream_copy) {
1958 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1959 exit_program(1);
1960 }
1961
1962 return ost;
1963 }
1964
new_attachment_stream(OptionsContext * o,AVFormatContext * oc,int source_index)1965 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1966 {
1967 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1968 ost->stream_copy = 1;
1969 ost->finished = 1;
1970 return ost;
1971 }
1972
new_subtitle_stream(OptionsContext * o,AVFormatContext * oc,int source_index)1973 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1974 {
1975 AVStream *st;
1976 OutputStream *ost;
1977 AVCodecContext *subtitle_enc;
1978
1979 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1980 st = ost->st;
1981 subtitle_enc = ost->enc_ctx;
1982
1983 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1984
1985 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1986
1987 if (!ost->stream_copy) {
1988 char *frame_size = NULL;
1989
1990 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1991 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1992 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1993 exit_program(1);
1994 }
1995 }
1996
1997 return ost;
1998 }
1999
2000 /* arg format is "output-stream-index:streamid-value". */
opt_streamid(void * optctx,const char * opt,const char * arg)2001 static int opt_streamid(void *optctx, const char *opt, const char *arg)
2002 {
2003 OptionsContext *o = optctx;
2004 int idx;
2005 char *p;
2006 char idx_str[16];
2007
2008 av_strlcpy(idx_str, arg, sizeof(idx_str));
2009 p = strchr(idx_str, ':');
2010 if (!p) {
2011 av_log(NULL, AV_LOG_FATAL,
2012 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
2013 arg, opt);
2014 exit_program(1);
2015 }
2016 *p++ = '\0';
2017 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
2018 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
2019 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
2020 return 0;
2021 }
2022
copy_chapters(InputFile * ifile,OutputFile * ofile,int copy_metadata)2023 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
2024 {
2025 AVFormatContext *is = ifile->ctx;
2026 AVFormatContext *os = ofile->ctx;
2027 AVChapter **tmp;
2028 int i;
2029
2030 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
2031 if (!tmp)
2032 return AVERROR(ENOMEM);
2033 os->chapters = tmp;
2034
2035 for (i = 0; i < is->nb_chapters; i++) {
2036 AVChapter *in_ch = is->chapters[i], *out_ch;
2037 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
2038 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
2039 AV_TIME_BASE_Q, in_ch->time_base);
2040 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
2041 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
2042
2043
2044 if (in_ch->end < ts_off)
2045 continue;
2046 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
2047 break;
2048
2049 out_ch = av_mallocz(sizeof(AVChapter));
2050 if (!out_ch)
2051 return AVERROR(ENOMEM);
2052
2053 out_ch->id = in_ch->id;
2054 out_ch->time_base = in_ch->time_base;
2055 out_ch->start = FFMAX(0, in_ch->start - ts_off);
2056 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
2057
2058 if (copy_metadata)
2059 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
2060
2061 os->chapters[os->nb_chapters++] = out_ch;
2062 }
2063 return 0;
2064 }
2065
init_output_filter(OutputFilter * ofilter,OptionsContext * o,AVFormatContext * oc)2066 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
2067 AVFormatContext *oc)
2068 {
2069 OutputStream *ost;
2070
2071 switch (ofilter->type) {
2072 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
2073 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
2074 default:
2075 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
2076 "currently.\n");
2077 exit_program(1);
2078 }
2079
2080 ost->source_index = -1;
2081 ost->filter = ofilter;
2082
2083 ofilter->ost = ost;
2084 ofilter->format = -1;
2085
2086 if (ost->stream_copy) {
2087 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
2088 "which is fed from a complex filtergraph. Filtering and streamcopy "
2089 "cannot be used together.\n", ost->file_index, ost->index);
2090 exit_program(1);
2091 }
2092
2093 if (ost->avfilter && (ost->filters || ost->filters_script)) {
2094 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
2095 av_log(NULL, AV_LOG_ERROR,
2096 "%s '%s' was specified through the %s option "
2097 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
2098 "%s and -filter_complex cannot be used together for the same stream.\n",
2099 ost->filters ? "Filtergraph" : "Filtergraph script",
2100 ost->filters ? ost->filters : ost->filters_script,
2101 opt, ost->file_index, ost->index, opt);
2102 exit_program(1);
2103 }
2104
2105 avfilter_inout_free(&ofilter->out_tmp);
2106 }
2107
init_complex_filters(void)2108 static int init_complex_filters(void)
2109 {
2110 int i, ret = 0;
2111
2112 for (i = 0; i < nb_filtergraphs; i++) {
2113 ret = init_complex_filtergraph(filtergraphs[i]);
2114 if (ret < 0)
2115 return ret;
2116 }
2117 return 0;
2118 }
2119
open_output_file(OptionsContext * o,const char * filename)2120 static int open_output_file(OptionsContext *o, const char *filename)
2121 {
2122 AVFormatContext *oc;
2123 int i, j, err;
2124 OutputFile *of;
2125 OutputStream *ost;
2126 InputStream *ist;
2127 AVDictionary *unused_opts = NULL;
2128 AVDictionaryEntry *e = NULL;
2129 int format_flags = 0;
2130
2131 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2132 o->stop_time = INT64_MAX;
2133 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2134 }
2135
2136 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2137 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2138 if (o->stop_time <= start_time) {
2139 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2140 exit_program(1);
2141 } else {
2142 o->recording_time = o->stop_time - start_time;
2143 }
2144 }
2145
2146 GROW_ARRAY(output_files, nb_output_files);
2147 of = av_mallocz(sizeof(*of));
2148 if (!of)
2149 exit_program(1);
2150 output_files[nb_output_files - 1] = of;
2151
2152 of->ost_index = nb_output_streams;
2153 of->recording_time = o->recording_time;
2154 of->start_time = o->start_time;
2155 of->limit_filesize = o->limit_filesize;
2156 of->shortest = o->shortest;
2157 av_dict_copy(&of->opts, o->g->format_opts, 0);
2158
2159 if (!strcmp(filename, "-"))
2160 filename = "pipe:";
2161
2162 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2163 if (!oc) {
2164 print_error(filename, err);
2165 exit_program(1);
2166 }
2167
2168 of->ctx = oc;
2169 if (o->recording_time != INT64_MAX)
2170 oc->duration = o->recording_time;
2171
2172 oc->interrupt_callback = int_cb;
2173
2174 e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2175 if (e) {
2176 const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2177 av_opt_eval_flags(oc, o, e->value, &format_flags);
2178 }
2179 if (o->bitexact) {
2180 format_flags |= AVFMT_FLAG_BITEXACT;
2181 oc->flags |= AVFMT_FLAG_BITEXACT;
2182 }
2183
2184 /* create streams for all unlabeled output pads */
2185 for (i = 0; i < nb_filtergraphs; i++) {
2186 FilterGraph *fg = filtergraphs[i];
2187 for (j = 0; j < fg->nb_outputs; j++) {
2188 OutputFilter *ofilter = fg->outputs[j];
2189
2190 if (!ofilter->out_tmp || ofilter->out_tmp->name)
2191 continue;
2192
2193 switch (ofilter->type) {
2194 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
2195 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2196 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2197 }
2198 init_output_filter(ofilter, o, oc);
2199 }
2200 }
2201
2202 if (!o->nb_stream_maps) {
2203 char *subtitle_codec_name = NULL;
2204 /* pick the "best" stream of each type */
2205
2206 /* video: highest resolution */
2207 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2208 int area = 0, idx = -1;
2209 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2210 for (i = 0; i < nb_input_streams; i++) {
2211 int new_area;
2212 ist = input_streams[i];
2213 new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames
2214 + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2215 if (ist->user_set_discard == AVDISCARD_ALL)
2216 continue;
2217 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2218 new_area = 1;
2219 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2220 new_area > area) {
2221 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2222 continue;
2223 area = new_area;
2224 idx = i;
2225 }
2226 }
2227 if (idx >= 0)
2228 new_video_stream(o, oc, idx);
2229 }
2230
2231 /* audio: most channels */
2232 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2233 int best_score = 0, idx = -1;
2234 for (i = 0; i < nb_input_streams; i++) {
2235 int score;
2236 ist = input_streams[i];
2237 score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames
2238 + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2239 if (ist->user_set_discard == AVDISCARD_ALL)
2240 continue;
2241 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2242 score > best_score) {
2243 best_score = score;
2244 idx = i;
2245 }
2246 }
2247 if (idx >= 0)
2248 new_audio_stream(o, oc, idx);
2249 }
2250
2251 /* subtitles: pick first */
2252 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2253 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2254 for (i = 0; i < nb_input_streams; i++)
2255 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2256 AVCodecDescriptor const *input_descriptor =
2257 avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2258 AVCodecDescriptor const *output_descriptor = NULL;
2259 AVCodec const *output_codec =
2260 avcodec_find_encoder(oc->oformat->subtitle_codec);
2261 int input_props = 0, output_props = 0;
2262 if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2263 continue;
2264 if (output_codec)
2265 output_descriptor = avcodec_descriptor_get(output_codec->id);
2266 if (input_descriptor)
2267 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2268 if (output_descriptor)
2269 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2270 if (subtitle_codec_name ||
2271 input_props & output_props ||
2272 // Map dvb teletext which has neither property to any output subtitle encoder
2273 input_descriptor && output_descriptor &&
2274 (!input_descriptor->props ||
2275 !output_descriptor->props)) {
2276 new_subtitle_stream(o, oc, i);
2277 break;
2278 }
2279 }
2280 }
2281 /* Data only if codec id match */
2282 if (!o->data_disable ) {
2283 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2284 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2285 if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2286 continue;
2287 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2288 && input_streams[i]->st->codecpar->codec_id == codec_id )
2289 new_data_stream(o, oc, i);
2290 }
2291 }
2292 } else {
2293 for (i = 0; i < o->nb_stream_maps; i++) {
2294 StreamMap *map = &o->stream_maps[i];
2295
2296 if (map->disabled)
2297 continue;
2298
2299 if (map->linklabel) {
2300 FilterGraph *fg;
2301 OutputFilter *ofilter = NULL;
2302 int j, k;
2303
2304 for (j = 0; j < nb_filtergraphs; j++) {
2305 fg = filtergraphs[j];
2306 for (k = 0; k < fg->nb_outputs; k++) {
2307 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2308 if (out && !strcmp(out->name, map->linklabel)) {
2309 ofilter = fg->outputs[k];
2310 goto loop_end;
2311 }
2312 }
2313 }
2314 loop_end:
2315 if (!ofilter) {
2316 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2317 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2318 exit_program(1);
2319 }
2320 init_output_filter(ofilter, o, oc);
2321 } else {
2322 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2323
2324 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2325 if (ist->user_set_discard == AVDISCARD_ALL) {
2326 av_log(NULL, AV_LOG_FATAL, "Stream #%d:%d is disabled and cannot be mapped.\n",
2327 map->file_index, map->stream_index);
2328 exit_program(1);
2329 }
2330 if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2331 continue;
2332 if(o-> audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2333 continue;
2334 if(o-> video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2335 continue;
2336 if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2337 continue;
2338
2339 ost = NULL;
2340 switch (ist->st->codecpar->codec_type) {
2341 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2342 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2343 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2344 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2345 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2346 case AVMEDIA_TYPE_UNKNOWN:
2347 if (copy_unknown_streams) {
2348 ost = new_unknown_stream (o, oc, src_idx);
2349 break;
2350 }
2351 default:
2352 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2353 "Cannot map stream #%d:%d - unsupported type.\n",
2354 map->file_index, map->stream_index);
2355 if (!ignore_unknown_streams) {
2356 av_log(NULL, AV_LOG_FATAL,
2357 "If you want unsupported types ignored instead "
2358 "of failing, please use the -ignore_unknown option\n"
2359 "If you want them copied, please use -copy_unknown\n");
2360 exit_program(1);
2361 }
2362 }
2363 if (ost)
2364 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2365 + map->sync_stream_index];
2366 }
2367 }
2368 }
2369
2370 /* handle attached files */
2371 for (i = 0; i < o->nb_attachments; i++) {
2372 AVIOContext *pb;
2373 uint8_t *attachment;
2374 const char *p;
2375 int64_t len;
2376
2377 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2378 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2379 o->attachments[i]);
2380 exit_program(1);
2381 }
2382 if ((len = avio_size(pb)) <= 0) {
2383 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2384 o->attachments[i]);
2385 exit_program(1);
2386 }
2387 if (len > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE ||
2388 !(attachment = av_malloc(len + AV_INPUT_BUFFER_PADDING_SIZE))) {
2389 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large.\n",
2390 o->attachments[i]);
2391 exit_program(1);
2392 }
2393 avio_read(pb, attachment, len);
2394 memset(attachment + len, 0, AV_INPUT_BUFFER_PADDING_SIZE);
2395
2396 ost = new_attachment_stream(o, oc, -1);
2397 ost->stream_copy = 0;
2398 ost->attachment_filename = o->attachments[i];
2399 ost->st->codecpar->extradata = attachment;
2400 ost->st->codecpar->extradata_size = len;
2401
2402 p = strrchr(o->attachments[i], '/');
2403 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2404 avio_closep(&pb);
2405 }
2406
2407 #if FF_API_LAVF_AVCTX
2408 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2409 AVDictionaryEntry *e;
2410 ost = output_streams[i];
2411
2412 if ((ost->stream_copy || ost->attachment_filename)
2413 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2414 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2415 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2416 exit_program(1);
2417 }
2418 #endif
2419
2420 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2421 av_dump_format(oc, nb_output_files - 1, oc->url, 1);
2422 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2423 exit_program(1);
2424 }
2425
2426 /* check if all codec options have been used */
2427 unused_opts = strip_specifiers(o->g->codec_opts);
2428 for (i = of->ost_index; i < nb_output_streams; i++) {
2429 e = NULL;
2430 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2431 AV_DICT_IGNORE_SUFFIX)))
2432 av_dict_set(&unused_opts, e->key, NULL, 0);
2433 }
2434
2435 e = NULL;
2436 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2437 const AVClass *class = avcodec_get_class();
2438 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2439 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2440 const AVClass *fclass = avformat_get_class();
2441 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2442 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2443 if (!option || foption)
2444 continue;
2445
2446
2447 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2448 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2449 "output file #%d (%s) is not an encoding option.\n", e->key,
2450 option->help ? option->help : "", nb_output_files - 1,
2451 filename);
2452 exit_program(1);
2453 }
2454
2455 // gop_timecode is injected by generic code but not always used
2456 if (!strcmp(e->key, "gop_timecode"))
2457 continue;
2458
2459 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2460 "output file #%d (%s) has not been used for any stream. The most "
2461 "likely reason is either wrong type (e.g. a video option with "
2462 "no video streams) or that it is a private option of some encoder "
2463 "which was not actually used for any stream.\n", e->key,
2464 option->help ? option->help : "", nb_output_files - 1, filename);
2465 }
2466 av_dict_free(&unused_opts);
2467
2468 /* set the decoding_needed flags and create simple filtergraphs */
2469 for (i = of->ost_index; i < nb_output_streams; i++) {
2470 OutputStream *ost = output_streams[i];
2471
2472 if (ost->encoding_needed && ost->source_index >= 0) {
2473 InputStream *ist = input_streams[ost->source_index];
2474 ist->decoding_needed |= DECODING_FOR_OST;
2475
2476 if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2477 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2478 err = init_simple_filtergraph(ist, ost);
2479 if (err < 0) {
2480 av_log(NULL, AV_LOG_ERROR,
2481 "Error initializing a simple filtergraph between streams "
2482 "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2483 nb_output_files - 1, ost->st->index);
2484 exit_program(1);
2485 }
2486 }
2487 }
2488
2489 /* set the filter output constraints */
2490 if (ost->filter) {
2491 OutputFilter *f = ost->filter;
2492 int count;
2493 switch (ost->enc_ctx->codec_type) {
2494 case AVMEDIA_TYPE_VIDEO:
2495 f->frame_rate = ost->frame_rate;
2496 f->width = ost->enc_ctx->width;
2497 f->height = ost->enc_ctx->height;
2498 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2499 f->format = ost->enc_ctx->pix_fmt;
2500 } else if (ost->enc->pix_fmts) {
2501 count = 0;
2502 while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2503 count++;
2504 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2505 if (!f->formats)
2506 exit_program(1);
2507 memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2508 }
2509 break;
2510 case AVMEDIA_TYPE_AUDIO:
2511 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2512 f->format = ost->enc_ctx->sample_fmt;
2513 } else if (ost->enc->sample_fmts) {
2514 count = 0;
2515 while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2516 count++;
2517 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2518 if (!f->formats)
2519 exit_program(1);
2520 memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2521 }
2522 if (ost->enc_ctx->sample_rate) {
2523 f->sample_rate = ost->enc_ctx->sample_rate;
2524 } else if (ost->enc->supported_samplerates) {
2525 count = 0;
2526 while (ost->enc->supported_samplerates[count])
2527 count++;
2528 f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2529 if (!f->sample_rates)
2530 exit_program(1);
2531 memcpy(f->sample_rates, ost->enc->supported_samplerates,
2532 (count + 1) * sizeof(*f->sample_rates));
2533 }
2534 if (ost->enc_ctx->channels) {
2535 f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2536 } else if (ost->enc->channel_layouts) {
2537 count = 0;
2538 while (ost->enc->channel_layouts[count])
2539 count++;
2540 f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2541 if (!f->channel_layouts)
2542 exit_program(1);
2543 memcpy(f->channel_layouts, ost->enc->channel_layouts,
2544 (count + 1) * sizeof(*f->channel_layouts));
2545 }
2546 break;
2547 }
2548 }
2549 }
2550
2551 /* check filename in case of an image number is expected */
2552 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2553 if (!av_filename_number_test(oc->url)) {
2554 print_error(oc->url, AVERROR(EINVAL));
2555 exit_program(1);
2556 }
2557 }
2558
2559 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2560 av_log(NULL, AV_LOG_ERROR,
2561 "No input streams but output needs an input stream\n");
2562 exit_program(1);
2563 }
2564
2565 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2566 /* test if it already exists to avoid losing precious files */
2567 assert_file_overwrite(filename);
2568
2569 /* open the file */
2570 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2571 &oc->interrupt_callback,
2572 &of->opts)) < 0) {
2573 print_error(filename, err);
2574 exit_program(1);
2575 }
2576 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2577 assert_file_overwrite(filename);
2578
2579 if (o->mux_preload) {
2580 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2581 }
2582 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2583
2584 /* copy metadata */
2585 for (i = 0; i < o->nb_metadata_map; i++) {
2586 char *p;
2587 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2588
2589 if (in_file_index >= nb_input_files) {
2590 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2591 exit_program(1);
2592 }
2593 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2594 in_file_index >= 0 ?
2595 input_files[in_file_index]->ctx : NULL, o);
2596 }
2597
2598 /* copy chapters */
2599 if (o->chapters_input_file >= nb_input_files) {
2600 if (o->chapters_input_file == INT_MAX) {
2601 /* copy chapters from the first input file that has them*/
2602 o->chapters_input_file = -1;
2603 for (i = 0; i < nb_input_files; i++)
2604 if (input_files[i]->ctx->nb_chapters) {
2605 o->chapters_input_file = i;
2606 break;
2607 }
2608 } else {
2609 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2610 o->chapters_input_file);
2611 exit_program(1);
2612 }
2613 }
2614 if (o->chapters_input_file >= 0)
2615 copy_chapters(input_files[o->chapters_input_file], of,
2616 !o->metadata_chapters_manual);
2617
2618 /* copy global metadata by default */
2619 if (!o->metadata_global_manual && nb_input_files){
2620 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2621 AV_DICT_DONT_OVERWRITE);
2622 if(o->recording_time != INT64_MAX)
2623 av_dict_set(&oc->metadata, "duration", NULL, 0);
2624 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2625 }
2626 if (!o->metadata_streams_manual)
2627 for (i = of->ost_index; i < nb_output_streams; i++) {
2628 InputStream *ist;
2629 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2630 continue;
2631 ist = input_streams[output_streams[i]->source_index];
2632 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2633 if (!output_streams[i]->stream_copy) {
2634 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2635 }
2636 }
2637
2638 /* process manually set programs */
2639 for (i = 0; i < o->nb_program; i++) {
2640 const char *p = o->program[i].u.str;
2641 int progid = i+1;
2642 AVProgram *program;
2643
2644 while(*p) {
2645 const char *p2 = av_get_token(&p, ":");
2646 const char *to_dealloc = p2;
2647 char *key;
2648 if (!p2)
2649 break;
2650
2651 if(*p) p++;
2652
2653 key = av_get_token(&p2, "=");
2654 if (!key || !*p2) {
2655 av_freep(&to_dealloc);
2656 av_freep(&key);
2657 break;
2658 }
2659 p2++;
2660
2661 if (!strcmp(key, "program_num"))
2662 progid = strtol(p2, NULL, 0);
2663 av_freep(&to_dealloc);
2664 av_freep(&key);
2665 }
2666
2667 program = av_new_program(oc, progid);
2668
2669 p = o->program[i].u.str;
2670 while(*p) {
2671 const char *p2 = av_get_token(&p, ":");
2672 const char *to_dealloc = p2;
2673 char *key;
2674 if (!p2)
2675 break;
2676 if(*p) p++;
2677
2678 key = av_get_token(&p2, "=");
2679 if (!key) {
2680 av_log(NULL, AV_LOG_FATAL,
2681 "No '=' character in program string %s.\n",
2682 p2);
2683 exit_program(1);
2684 }
2685 if (!*p2)
2686 exit_program(1);
2687 p2++;
2688
2689 if (!strcmp(key, "title")) {
2690 av_dict_set(&program->metadata, "title", p2, 0);
2691 } else if (!strcmp(key, "program_num")) {
2692 } else if (!strcmp(key, "st")) {
2693 int st_num = strtol(p2, NULL, 0);
2694 av_program_add_stream_index(oc, progid, st_num);
2695 } else {
2696 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2697 exit_program(1);
2698 }
2699 av_freep(&to_dealloc);
2700 av_freep(&key);
2701 }
2702 }
2703
2704 /* process manually set metadata */
2705 for (i = 0; i < o->nb_metadata; i++) {
2706 AVDictionary **m;
2707 char type, *val;
2708 const char *stream_spec;
2709 int index = 0, j, ret = 0;
2710
2711 val = strchr(o->metadata[i].u.str, '=');
2712 if (!val) {
2713 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2714 o->metadata[i].u.str);
2715 exit_program(1);
2716 }
2717 *val++ = 0;
2718
2719 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2720 if (type == 's') {
2721 for (j = 0; j < oc->nb_streams; j++) {
2722 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2723 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2724 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2725 char *tail;
2726 double theta = av_strtod(val, &tail);
2727 if (!*tail) {
2728 ost->rotate_overridden = 1;
2729 ost->rotate_override_value = theta;
2730 }
2731 } else {
2732 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2733 }
2734 } else if (ret < 0)
2735 exit_program(1);
2736 }
2737 }
2738 else {
2739 switch (type) {
2740 case 'g':
2741 m = &oc->metadata;
2742 break;
2743 case 'c':
2744 if (index < 0 || index >= oc->nb_chapters) {
2745 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2746 exit_program(1);
2747 }
2748 m = &oc->chapters[index]->metadata;
2749 break;
2750 case 'p':
2751 if (index < 0 || index >= oc->nb_programs) {
2752 av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2753 exit_program(1);
2754 }
2755 m = &oc->programs[index]->metadata;
2756 break;
2757 default:
2758 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2759 exit_program(1);
2760 }
2761 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2762 }
2763 }
2764
2765 return 0;
2766 }
2767
opt_target(void * optctx,const char * opt,const char * arg)2768 static int opt_target(void *optctx, const char *opt, const char *arg)
2769 {
2770 OptionsContext *o = optctx;
2771 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2772 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2773
2774 if (!strncmp(arg, "pal-", 4)) {
2775 norm = PAL;
2776 arg += 4;
2777 } else if (!strncmp(arg, "ntsc-", 5)) {
2778 norm = NTSC;
2779 arg += 5;
2780 } else if (!strncmp(arg, "film-", 5)) {
2781 norm = FILM;
2782 arg += 5;
2783 } else {
2784 /* Try to determine PAL/NTSC by peeking in the input files */
2785 if (nb_input_files) {
2786 int i, j;
2787 for (j = 0; j < nb_input_files; j++) {
2788 for (i = 0; i < input_files[j]->nb_streams; i++) {
2789 AVStream *st = input_files[j]->ctx->streams[i];
2790 int64_t fr;
2791 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2792 continue;
2793 fr = st->time_base.den * 1000LL / st->time_base.num;
2794 if (fr == 25000) {
2795 norm = PAL;
2796 break;
2797 } else if ((fr == 29970) || (fr == 23976)) {
2798 norm = NTSC;
2799 break;
2800 }
2801 }
2802 if (norm != UNKNOWN)
2803 break;
2804 }
2805 }
2806 if (norm != UNKNOWN)
2807 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2808 }
2809
2810 if (norm == UNKNOWN) {
2811 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2812 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2813 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2814 exit_program(1);
2815 }
2816
2817 if (!strcmp(arg, "vcd")) {
2818 opt_video_codec(o, "c:v", "mpeg1video");
2819 opt_audio_codec(o, "c:a", "mp2");
2820 parse_option(o, "f", "vcd", options);
2821
2822 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2823 parse_option(o, "r", frame_rates[norm], options);
2824 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2825
2826 opt_default(NULL, "b:v", "1150000");
2827 opt_default(NULL, "maxrate:v", "1150000");
2828 opt_default(NULL, "minrate:v", "1150000");
2829 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2830
2831 opt_default(NULL, "b:a", "224000");
2832 parse_option(o, "ar", "44100", options);
2833 parse_option(o, "ac", "2", options);
2834
2835 opt_default(NULL, "packetsize", "2324");
2836 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2837
2838 /* We have to offset the PTS, so that it is consistent with the SCR.
2839 SCR starts at 36000, but the first two packs contain only padding
2840 and the first pack from the other stream, respectively, may also have
2841 been written before.
2842 So the real data starts at SCR 36000+3*1200. */
2843 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2844 } else if (!strcmp(arg, "svcd")) {
2845
2846 opt_video_codec(o, "c:v", "mpeg2video");
2847 opt_audio_codec(o, "c:a", "mp2");
2848 parse_option(o, "f", "svcd", options);
2849
2850 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2851 parse_option(o, "r", frame_rates[norm], options);
2852 parse_option(o, "pix_fmt", "yuv420p", options);
2853 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2854
2855 opt_default(NULL, "b:v", "2040000");
2856 opt_default(NULL, "maxrate:v", "2516000");
2857 opt_default(NULL, "minrate:v", "0"); // 1145000;
2858 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2859 opt_default(NULL, "scan_offset", "1");
2860
2861 opt_default(NULL, "b:a", "224000");
2862 parse_option(o, "ar", "44100", options);
2863
2864 opt_default(NULL, "packetsize", "2324");
2865
2866 } else if (!strcmp(arg, "dvd")) {
2867
2868 opt_video_codec(o, "c:v", "mpeg2video");
2869 opt_audio_codec(o, "c:a", "ac3");
2870 parse_option(o, "f", "dvd", options);
2871
2872 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2873 parse_option(o, "r", frame_rates[norm], options);
2874 parse_option(o, "pix_fmt", "yuv420p", options);
2875 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2876
2877 opt_default(NULL, "b:v", "6000000");
2878 opt_default(NULL, "maxrate:v", "9000000");
2879 opt_default(NULL, "minrate:v", "0"); // 1500000;
2880 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2881
2882 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2883 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2884
2885 opt_default(NULL, "b:a", "448000");
2886 parse_option(o, "ar", "48000", options);
2887
2888 } else if (!strncmp(arg, "dv", 2)) {
2889
2890 parse_option(o, "f", "dv", options);
2891
2892 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2893 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2894 norm == PAL ? "yuv420p" : "yuv411p", options);
2895 parse_option(o, "r", frame_rates[norm], options);
2896
2897 parse_option(o, "ar", "48000", options);
2898 parse_option(o, "ac", "2", options);
2899
2900 } else {
2901 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2902 return AVERROR(EINVAL);
2903 }
2904
2905 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2906 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2907
2908 return 0;
2909 }
2910
opt_vstats_file(void * optctx,const char * opt,const char * arg)2911 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2912 {
2913 av_free (vstats_filename);
2914 vstats_filename = av_strdup (arg);
2915 return 0;
2916 }
2917
opt_vstats(void * optctx,const char * opt,const char * arg)2918 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2919 {
2920 char filename[40];
2921 time_t today2 = time(NULL);
2922 struct tm *today = localtime(&today2);
2923
2924 if (!today) { // maybe tomorrow
2925 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2926 exit_program(1);
2927 }
2928
2929 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2930 today->tm_sec);
2931 return opt_vstats_file(NULL, opt, filename);
2932 }
2933
opt_video_frames(void * optctx,const char * opt,const char * arg)2934 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2935 {
2936 OptionsContext *o = optctx;
2937 return parse_option(o, "frames:v", arg, options);
2938 }
2939
opt_audio_frames(void * optctx,const char * opt,const char * arg)2940 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2941 {
2942 OptionsContext *o = optctx;
2943 return parse_option(o, "frames:a", arg, options);
2944 }
2945
opt_data_frames(void * optctx,const char * opt,const char * arg)2946 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2947 {
2948 OptionsContext *o = optctx;
2949 return parse_option(o, "frames:d", arg, options);
2950 }
2951
opt_default_new(OptionsContext * o,const char * opt,const char * arg)2952 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2953 {
2954 int ret;
2955 AVDictionary *cbak = codec_opts;
2956 AVDictionary *fbak = format_opts;
2957 codec_opts = NULL;
2958 format_opts = NULL;
2959
2960 ret = opt_default(NULL, opt, arg);
2961
2962 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2963 av_dict_copy(&o->g->format_opts, format_opts, 0);
2964 av_dict_free(&codec_opts);
2965 av_dict_free(&format_opts);
2966 codec_opts = cbak;
2967 format_opts = fbak;
2968
2969 return ret;
2970 }
2971
opt_preset(void * optctx,const char * opt,const char * arg)2972 static int opt_preset(void *optctx, const char *opt, const char *arg)
2973 {
2974 OptionsContext *o = optctx;
2975 FILE *f=NULL;
2976 char filename[1000], line[1000], tmp_line[1000];
2977 const char *codec_name = NULL;
2978
2979 tmp_line[0] = *opt;
2980 tmp_line[1] = 0;
2981 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2982
2983 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2984 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2985 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2986 }else
2987 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2988 exit_program(1);
2989 }
2990
2991 while (fgets(line, sizeof(line), f)) {
2992 char *key = tmp_line, *value, *endptr;
2993
2994 if (strcspn(line, "#\n\r") == 0)
2995 continue;
2996 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2997 if (!av_strtok(key, "=", &value) ||
2998 !av_strtok(value, "\r\n", &endptr)) {
2999 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
3000 exit_program(1);
3001 }
3002 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
3003
3004 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
3005 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
3006 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
3007 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
3008 else if (opt_default_new(o, key, value) < 0) {
3009 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
3010 filename, line, key, value);
3011 exit_program(1);
3012 }
3013 }
3014
3015 fclose(f);
3016
3017 return 0;
3018 }
3019
opt_old2new(void * optctx,const char * opt,const char * arg)3020 static int opt_old2new(void *optctx, const char *opt, const char *arg)
3021 {
3022 OptionsContext *o = optctx;
3023 int ret;
3024 char *s = av_asprintf("%s:%c", opt + 1, *opt);
3025 if (!s)
3026 return AVERROR(ENOMEM);
3027 ret = parse_option(o, s, arg, options);
3028 av_free(s);
3029 return ret;
3030 }
3031
opt_bitrate(void * optctx,const char * opt,const char * arg)3032 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
3033 {
3034 OptionsContext *o = optctx;
3035
3036 if(!strcmp(opt, "ab")){
3037 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
3038 return 0;
3039 } else if(!strcmp(opt, "b")){
3040 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
3041 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
3042 return 0;
3043 }
3044 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3045 return 0;
3046 }
3047
opt_qscale(void * optctx,const char * opt,const char * arg)3048 static int opt_qscale(void *optctx, const char *opt, const char *arg)
3049 {
3050 OptionsContext *o = optctx;
3051 char *s;
3052 int ret;
3053 if(!strcmp(opt, "qscale")){
3054 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
3055 return parse_option(o, "q:v", arg, options);
3056 }
3057 s = av_asprintf("q%s", opt + 6);
3058 if (!s)
3059 return AVERROR(ENOMEM);
3060 ret = parse_option(o, s, arg, options);
3061 av_free(s);
3062 return ret;
3063 }
3064
opt_profile(void * optctx,const char * opt,const char * arg)3065 static int opt_profile(void *optctx, const char *opt, const char *arg)
3066 {
3067 OptionsContext *o = optctx;
3068 if(!strcmp(opt, "profile")){
3069 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
3070 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
3071 return 0;
3072 }
3073 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3074 return 0;
3075 }
3076
opt_video_filters(void * optctx,const char * opt,const char * arg)3077 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3078 {
3079 OptionsContext *o = optctx;
3080 return parse_option(o, "filter:v", arg, options);
3081 }
3082
opt_audio_filters(void * optctx,const char * opt,const char * arg)3083 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3084 {
3085 OptionsContext *o = optctx;
3086 return parse_option(o, "filter:a", arg, options);
3087 }
3088
opt_vsync(void * optctx,const char * opt,const char * arg)3089 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3090 {
3091 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
3092 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
3093 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3094 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
3095
3096 if (video_sync_method == VSYNC_AUTO)
3097 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
3098 return 0;
3099 }
3100
opt_timecode(void * optctx,const char * opt,const char * arg)3101 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3102 {
3103 OptionsContext *o = optctx;
3104 int ret;
3105 char *tcr = av_asprintf("timecode=%s", arg);
3106 if (!tcr)
3107 return AVERROR(ENOMEM);
3108 ret = parse_option(o, "metadata:g", tcr, options);
3109 if (ret >= 0)
3110 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3111 av_free(tcr);
3112 return ret;
3113 }
3114
opt_channel_layout(void * optctx,const char * opt,const char * arg)3115 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3116 {
3117 OptionsContext *o = optctx;
3118 char layout_str[32];
3119 char *stream_str;
3120 char *ac_str;
3121 int ret, channels, ac_str_size;
3122 uint64_t layout;
3123
3124 layout = av_get_channel_layout(arg);
3125 if (!layout) {
3126 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3127 return AVERROR(EINVAL);
3128 }
3129 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3130 ret = opt_default_new(o, opt, layout_str);
3131 if (ret < 0)
3132 return ret;
3133
3134 /* set 'ac' option based on channel layout */
3135 channels = av_get_channel_layout_nb_channels(layout);
3136 snprintf(layout_str, sizeof(layout_str), "%d", channels);
3137 stream_str = strchr(opt, ':');
3138 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3139 ac_str = av_mallocz(ac_str_size);
3140 if (!ac_str)
3141 return AVERROR(ENOMEM);
3142 av_strlcpy(ac_str, "ac", 3);
3143 if (stream_str)
3144 av_strlcat(ac_str, stream_str, ac_str_size);
3145 ret = parse_option(o, ac_str, layout_str, options);
3146 av_free(ac_str);
3147
3148 return ret;
3149 }
3150
opt_audio_qscale(void * optctx,const char * opt,const char * arg)3151 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3152 {
3153 OptionsContext *o = optctx;
3154 return parse_option(o, "q:a", arg, options);
3155 }
3156
opt_filter_complex(void * optctx,const char * opt,const char * arg)3157 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3158 {
3159 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3160 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3161 return AVERROR(ENOMEM);
3162 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3163 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
3164 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3165 return AVERROR(ENOMEM);
3166
3167 input_stream_potentially_available = 1;
3168
3169 return 0;
3170 }
3171
opt_filter_complex_script(void * optctx,const char * opt,const char * arg)3172 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3173 {
3174 uint8_t *graph_desc = read_file(arg);
3175 if (!graph_desc)
3176 return AVERROR(EINVAL);
3177
3178 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3179 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3180 return AVERROR(ENOMEM);
3181 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3182 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3183
3184 input_stream_potentially_available = 1;
3185
3186 return 0;
3187 }
3188
show_help_default(const char * opt,const char * arg)3189 void show_help_default(const char *opt, const char *arg)
3190 {
3191 /* per-file options have at least one of those set */
3192 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3193 int show_advanced = 0, show_avoptions = 0;
3194
3195 if (opt && *opt) {
3196 if (!strcmp(opt, "long"))
3197 show_advanced = 1;
3198 else if (!strcmp(opt, "full"))
3199 show_advanced = show_avoptions = 1;
3200 else
3201 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3202 }
3203
3204 show_usage();
3205
3206 printf("Getting help:\n"
3207 " -h -- print basic options\n"
3208 " -h long -- print more options\n"
3209 " -h full -- print all options (including all format and codec specific options, very long)\n"
3210 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter/bsf/protocol\n"
3211 " See man %s for detailed description of the options.\n"
3212 "\n", program_name);
3213
3214 show_help_options(options, "Print help / information / capabilities:",
3215 OPT_EXIT, 0, 0);
3216
3217 show_help_options(options, "Global options (affect whole program "
3218 "instead of just one file):",
3219 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3220 if (show_advanced)
3221 show_help_options(options, "Advanced global options:", OPT_EXPERT,
3222 per_file | OPT_EXIT, 0);
3223
3224 show_help_options(options, "Per-file main options:", 0,
3225 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3226 OPT_EXIT, per_file);
3227 if (show_advanced)
3228 show_help_options(options, "Advanced per-file options:",
3229 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3230
3231 show_help_options(options, "Video options:",
3232 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3233 if (show_advanced)
3234 show_help_options(options, "Advanced Video options:",
3235 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3236
3237 show_help_options(options, "Audio options:",
3238 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3239 if (show_advanced)
3240 show_help_options(options, "Advanced Audio options:",
3241 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3242 show_help_options(options, "Subtitle options:",
3243 OPT_SUBTITLE, 0, 0);
3244 printf("\n");
3245
3246 if (show_avoptions) {
3247 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3248 show_help_children(avcodec_get_class(), flags);
3249 show_help_children(avformat_get_class(), flags);
3250 #if CONFIG_SWSCALE
3251 show_help_children(sws_get_class(), flags);
3252 #endif
3253 #if CONFIG_SWRESAMPLE
3254 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3255 #endif
3256 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3257 show_help_children(av_bsf_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_BSF_PARAM);
3258 }
3259 }
3260
show_usage(void)3261 void show_usage(void)
3262 {
3263 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3264 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3265 av_log(NULL, AV_LOG_INFO, "\n");
3266 }
3267
3268 enum OptGroup {
3269 GROUP_OUTFILE,
3270 GROUP_INFILE,
3271 };
3272
3273 static const OptionGroupDef groups[] = {
3274 [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
3275 [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
3276 };
3277
open_files(OptionGroupList * l,const char * inout,int (* open_file)(OptionsContext *,const char *))3278 static int open_files(OptionGroupList *l, const char *inout,
3279 int (*open_file)(OptionsContext*, const char*))
3280 {
3281 int i, ret;
3282
3283 for (i = 0; i < l->nb_groups; i++) {
3284 OptionGroup *g = &l->groups[i];
3285 OptionsContext o;
3286
3287 init_options(&o);
3288 o.g = g;
3289
3290 ret = parse_optgroup(&o, g);
3291 if (ret < 0) {
3292 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3293 "%s.\n", inout, g->arg);
3294 uninit_options(&o);
3295 return ret;
3296 }
3297
3298 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3299 ret = open_file(&o, g->arg);
3300 uninit_options(&o);
3301 if (ret < 0) {
3302 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3303 inout, g->arg);
3304 return ret;
3305 }
3306 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3307 }
3308
3309 return 0;
3310 }
3311
ffmpeg_parse_options(int argc,char ** argv)3312 int ffmpeg_parse_options(int argc, char **argv)
3313 {
3314 OptionParseContext octx;
3315 uint8_t error[128];
3316 int ret;
3317
3318 memset(&octx, 0, sizeof(octx));
3319
3320 /* split the commandline into an internal representation */
3321 ret = split_commandline(&octx, argc, argv, options, groups,
3322 FF_ARRAY_ELEMS(groups));
3323 if (ret < 0) {
3324 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3325 goto fail;
3326 }
3327
3328 /* apply global options */
3329 ret = parse_optgroup(NULL, &octx.global_opts);
3330 if (ret < 0) {
3331 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3332 goto fail;
3333 }
3334
3335 /* configure terminal and setup signal handlers */
3336 term_init();
3337
3338 /* open input files */
3339 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3340 if (ret < 0) {
3341 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3342 goto fail;
3343 }
3344
3345 /* create the complex filtergraphs */
3346 ret = init_complex_filters();
3347 if (ret < 0) {
3348 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3349 goto fail;
3350 }
3351
3352 /* open output files */
3353 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3354 if (ret < 0) {
3355 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3356 goto fail;
3357 }
3358
3359 check_filter_outputs();
3360
3361 fail:
3362 uninit_parse_context(&octx);
3363 if (ret < 0) {
3364 av_strerror(ret, error, sizeof(error));
3365 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3366 }
3367 return ret;
3368 }
3369
opt_progress(void * optctx,const char * opt,const char * arg)3370 static int opt_progress(void *optctx, const char *opt, const char *arg)
3371 {
3372 AVIOContext *avio = NULL;
3373 int ret;
3374
3375 if (!strcmp(arg, "-"))
3376 arg = "pipe:";
3377 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3378 if (ret < 0) {
3379 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3380 arg, av_err2str(ret));
3381 return ret;
3382 }
3383 progress_avio = avio;
3384 return 0;
3385 }
3386
3387 #define OFFSET(x) offsetof(OptionsContext, x)
3388 const OptionDef options[] = {
3389 /* main options */
3390 CMDUTILS_COMMON_OPTIONS
3391 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3392 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3393 "force format", "fmt" },
3394 { "y", OPT_BOOL, { &file_overwrite },
3395 "overwrite output files" },
3396 { "n", OPT_BOOL, { &no_file_overwrite },
3397 "never overwrite output files" },
3398 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3399 "Ignore unknown stream types" },
3400 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
3401 "Copy unknown stream types" },
3402 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3403 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3404 "codec name", "codec" },
3405 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3406 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3407 "codec name", "codec" },
3408 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3409 OPT_OUTPUT, { .off = OFFSET(presets) },
3410 "preset name", "preset" },
3411 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3412 OPT_OUTPUT, { .func_arg = opt_map },
3413 "set input stream mapping",
3414 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3415 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3416 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3417 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3418 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3419 "set metadata information of outfile from infile",
3420 "outfile[,metadata]:infile[,metadata]" },
3421 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3422 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3423 "set chapters mapping", "input_file_index" },
3424 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3425 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3426 "record or transcode \"duration\" seconds of audio/video",
3427 "duration" },
3428 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3429 "record or transcode stop time", "time_stop" },
3430 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3431 "set the limit file size in bytes", "limit_size" },
3432 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3433 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3434 "set the start time offset", "time_off" },
3435 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3436 OPT_INPUT, { .off = OFFSET(start_time_eof) },
3437 "set the start time offset relative to EOF", "time_off" },
3438 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3439 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3440 "enable/disable seeking by timestamp with -ss" },
3441 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3442 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3443 "enable/disable accurate seeking with -ss" },
3444 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3445 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3446 "set the input ts offset", "time_off" },
3447 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3448 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3449 "set the input ts scale", "scale" },
3450 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3451 "set the recording timestamp ('now' to set the current time)", "time" },
3452 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3453 "add metadata", "string=string" },
3454 { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3455 "add program with specified streams", "title=string:st=number..." },
3456 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3457 OPT_OUTPUT, { .func_arg = opt_data_frames },
3458 "set the number of data frames to output", "number" },
3459 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3460 "add timings for benchmarking" },
3461 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3462 "add timings for each task" },
3463 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3464 "write program-readable progress information", "url" },
3465 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3466 "enable or disable interaction on standard input" },
3467 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3468 "set max runtime in seconds in CPU user time", "limit" },
3469 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3470 "dump each input packet" },
3471 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3472 "when dumping packets, also dump the payload" },
3473 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3474 OPT_INPUT, { .off = OFFSET(rate_emu) },
3475 "read input at native frame rate", "" },
3476 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3477 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3478 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3479 { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3480 "video sync method", "" },
3481 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3482 "frame drop threshold", "" },
3483 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3484 "audio sync method", "" },
3485 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3486 "audio drift threshold", "threshold" },
3487 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3488 "copy timestamps" },
3489 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3490 "shift input timestamps to start at 0 when using copyts" },
3491 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3492 "copy input stream time base when stream copying", "mode" },
3493 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3494 OPT_OUTPUT, { .off = OFFSET(shortest) },
3495 "finish encoding within shortest input" },
3496 { "bitexact", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3497 OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(bitexact) },
3498 "bitexact mode" },
3499 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3500 OPT_OUTPUT, { .off = OFFSET(apad) },
3501 "audio pad", "" },
3502 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3503 "timestamp discontinuity delta threshold", "threshold" },
3504 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3505 "timestamp error delta threshold", "threshold" },
3506 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3507 "exit on error", "error" },
3508 { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3509 "abort on the specified condition flags", "flags" },
3510 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3511 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3512 "copy initial non-keyframes" },
3513 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3514 "copy or discard frames before start time" },
3515 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3516 "set the number of frames to output", "number" },
3517 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3518 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3519 "force codec tag/fourcc", "fourcc/tag" },
3520 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3521 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3522 "use fixed quality scale (VBR)", "q" },
3523 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3524 OPT_OUTPUT, { .func_arg = opt_qscale },
3525 "use fixed quality scale (VBR)", "q" },
3526 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3527 "set profile", "profile" },
3528 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3529 "set stream filtergraph", "filter_graph" },
3530 { "filter_threads", HAS_ARG | OPT_INT, { &filter_nbthreads },
3531 "number of non-complex filter threads" },
3532 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3533 "read stream filtergraph description from a file", "filename" },
3534 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3535 "reinit filtergraph on input parameter changes", "" },
3536 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3537 "create a complex filtergraph", "graph_description" },
3538 { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
3539 "number of threads for -filter_complex" },
3540 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3541 "create a complex filtergraph", "graph_description" },
3542 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3543 "read complex filtergraph description from a file", "filename" },
3544 { "stats", OPT_BOOL, { &print_stats },
3545 "print progress report during encoding", },
3546 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3547 OPT_OUTPUT, { .func_arg = opt_attach },
3548 "add an attachment to the output file", "filename" },
3549 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3550 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3551 "extract an attachment into a file", "filename" },
3552 { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3553 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3554 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3555 "print timestamp debugging info" },
3556 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3557 "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success.", "maximum error rate" },
3558 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3559 OPT_INPUT, { .off = OFFSET(discard) },
3560 "discard", "" },
3561 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3562 OPT_OUTPUT, { .off = OFFSET(disposition) },
3563 "disposition", "" },
3564 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3565 { .off = OFFSET(thread_queue_size) },
3566 "set the maximum number of queued packets from the demuxer" },
3567 { "find_stream_info", OPT_BOOL | OPT_PERFILE | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3568 "read and decode the streams to fill missing information with heuristics" },
3569
3570 /* video options */
3571 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3572 "set the number of video frames to output", "number" },
3573 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3574 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3575 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3576 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3577 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3578 "set frame size (WxH or abbreviation)", "size" },
3579 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3580 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3581 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3582 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3583 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3584 "set pixel format", "format" },
3585 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3586 "set the number of bits per raw sample", "number" },
3587 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3588 "deprecated use -g 1" },
3589 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3590 "disable video" },
3591 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3592 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3593 "rate control override for specific intervals", "override" },
3594 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3595 OPT_OUTPUT, { .func_arg = opt_video_codec },
3596 "force video codec ('copy' to copy stream)", "codec" },
3597 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3598 "Removed" },
3599 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3600 "Removed" },
3601 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3602 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3603 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3604 "select the pass number (1 to 3)", "n" },
3605 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3606 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3607 "select two pass log file name prefix", "prefix" },
3608 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3609 "this option is deprecated, use the yadif filter instead" },
3610 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3611 "calculate PSNR of compressed frames" },
3612 { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3613 "dump video coding statistics to file" },
3614 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3615 "dump video coding statistics to file", "file" },
3616 { "vstats_version", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &vstats_version },
3617 "Version of the vstats format to use."},
3618 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3619 "set video filters", "filter_graph" },
3620 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3621 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3622 "specify intra matrix coeffs", "matrix" },
3623 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3624 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3625 "specify inter matrix coeffs", "matrix" },
3626 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3627 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3628 "specify intra matrix coeffs", "matrix" },
3629 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3630 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3631 "top=1/bottom=0/auto=-1 field first", "" },
3632 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3633 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3634 "force video tag/fourcc", "fourcc/tag" },
3635 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3636 "show QP histogram" },
3637 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3638 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3639 "force the selected framerate, disable the best supported framerate selection" },
3640 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3641 OPT_OUTPUT, { .func_arg = opt_streamid },
3642 "set the value of an outfile streamid", "streamIndex:value" },
3643 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3644 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3645 "force key frames at specified timestamps", "timestamps" },
3646 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3647 "audio bitrate (please use -b:a)", "bitrate" },
3648 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3649 "video bitrate (please use -b:v)", "bitrate" },
3650 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3651 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3652 "use HW accelerated decoding", "hwaccel name" },
3653 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3654 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3655 "select a device for HW acceleration", "devicename" },
3656 { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3657 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3658 "select output format used with HW accelerated decoding", "format" },
3659 #if CONFIG_VIDEOTOOLBOX
3660 { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3661 #endif
3662 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3663 "show available HW acceleration methods" },
3664 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3665 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3666 "automatically insert correct rotate filters" },
3667
3668 /* audio options */
3669 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3670 "set the number of audio frames to output", "number" },
3671 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3672 "set audio quality (codec-specific)", "quality", },
3673 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3674 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3675 "set audio sampling rate (in Hz)", "rate" },
3676 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3677 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3678 "set number of audio channels", "channels" },
3679 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3680 "disable audio" },
3681 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3682 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3683 "force audio codec ('copy' to copy stream)", "codec" },
3684 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3685 OPT_OUTPUT, { .func_arg = opt_old2new },
3686 "force audio tag/fourcc", "fourcc/tag" },
3687 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3688 "change audio volume (256=normal)" , "volume" },
3689 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3690 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3691 "set sample format", "format" },
3692 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3693 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3694 "set channel layout", "layout" },
3695 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3696 "set audio filters", "filter_graph" },
3697 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3698 "set the maximum number of channels to try to guess the channel layout" },
3699
3700 /* subtitle options */
3701 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3702 "disable subtitle" },
3703 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3704 "force subtitle codec ('copy' to copy stream)", "codec" },
3705 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3706 , "force subtitle tag/fourcc", "fourcc/tag" },
3707 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3708 "fix subtitles duration" },
3709 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3710 "set canvas size (WxH or abbreviation)", "size" },
3711
3712 /* grab options */
3713 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3714 "deprecated, use -channel", "channel" },
3715 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3716 "deprecated, use -standard", "standard" },
3717 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3718
3719 /* muxer options */
3720 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3721 "set the maximum demux-decode delay", "seconds" },
3722 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3723 "set the initial demux-decode delay", "seconds" },
3724 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3725 "specify a file in which to print sdp information", "file" },
3726
3727 { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3728 "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3729 { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) },
3730 "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
3731 "two special values are defined - "
3732 "0 = use frame rate (video) or sample rate (audio),"
3733 "-1 = match source time base", "ratio" },
3734
3735 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3736 "A comma-separated list of bitstream filters", "bitstream_filters" },
3737 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3738 "deprecated", "audio bitstream_filters" },
3739 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3740 "deprecated", "video bitstream_filters" },
3741
3742 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3743 "set the audio options to the indicated preset", "preset" },
3744 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3745 "set the video options to the indicated preset", "preset" },
3746 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3747 "set the subtitle options to the indicated preset", "preset" },
3748 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3749 "set options from indicated preset file", "filename" },
3750
3751 { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3752 "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3753
3754 /* data codec support */
3755 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3756 "force data codec ('copy' to copy stream)", "codec" },
3757 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3758 "disable data" },
3759
3760 #if CONFIG_VAAPI
3761 { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3762 "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3763 #endif
3764
3765 #if CONFIG_QSV
3766 { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3767 "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
3768 #endif
3769
3770 { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
3771 "initialise hardware device", "args" },
3772 { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
3773 "set hardware device used when filtering", "device" },
3774
3775 { NULL, },
3776 };
3777