lagarith: Correctly compute hash_shift
[libav.git] / avconv_opt.c
1 /*
2 * avconv option parsing
3 *
4 * This file is part of Libav.
5 *
6 * Libav is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * Libav is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with Libav; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 #include <stdint.h>
22
23 #include "avconv.h"
24 #include "cmdutils.h"
25
26 #include "libavformat/avformat.h"
27
28 #include "libavcodec/avcodec.h"
29
30 #include "libavfilter/avfilter.h"
31
32 #include "libavutil/avassert.h"
33 #include "libavutil/avstring.h"
34 #include "libavutil/avutil.h"
35 #include "libavutil/channel_layout.h"
36 #include "libavutil/intreadwrite.h"
37 #include "libavutil/fifo.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/pixdesc.h"
42 #include "libavutil/pixfmt.h"
43
44 #define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"
45
46 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
47 {\
48 int i, ret;\
49 for (i = 0; i < o->nb_ ## name; i++) {\
50 char *spec = o->name[i].specifier;\
51 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
52 outvar = o->name[i].u.type;\
53 else if (ret < 0)\
54 exit_program(1);\
55 }\
56 }
57
58 const HWAccel hwaccels[] = {
59 #if HAVE_VDPAU_X11
60 { "vdpau", vdpau_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU },
61 #endif
62 #if HAVE_DXVA2_LIB
63 { "dxva2", dxva2_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD },
64 #endif
65 #if CONFIG_VDA
66 { "vda", vda_init, HWACCEL_VDA, AV_PIX_FMT_VDA },
67 #endif
68 #if CONFIG_LIBMFX
69 { "qsv", qsv_init, HWACCEL_QSV, AV_PIX_FMT_QSV },
70 #endif
71 { 0 },
72 };
73
74 char *vstats_filename;
75
76 float audio_drift_threshold = 0.1;
77 float dts_delta_threshold = 10;
78
79 int audio_volume = 256;
80 int audio_sync_method = 0;
81 int video_sync_method = VSYNC_AUTO;
82 int do_benchmark = 0;
83 int do_hex_dump = 0;
84 int do_pkt_dump = 0;
85 int copy_ts = 0;
86 int copy_tb = 1;
87 int exit_on_error = 0;
88 int print_stats = 1;
89 int qp_hist = 0;
90
91 static int file_overwrite = 0;
92 static int file_skip = 0;
93 static int video_discard = 0;
94 static int intra_dc_precision = 8;
95 static int using_stdin = 0;
96 static int input_sync;
97
98 static void uninit_options(OptionsContext *o)
99 {
100 const OptionDef *po = options;
101 int i;
102
103 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
104 while (po->name) {
105 void *dst = (uint8_t*)o + po->u.off;
106
107 if (po->flags & OPT_SPEC) {
108 SpecifierOpt **so = dst;
109 int i, *count = (int*)(so + 1);
110 for (i = 0; i < *count; i++) {
111 av_freep(&(*so)[i].specifier);
112 if (po->flags & OPT_STRING)
113 av_freep(&(*so)[i].u.str);
114 }
115 av_freep(so);
116 *count = 0;
117 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
118 av_freep(dst);
119 po++;
120 }
121
122 for (i = 0; i < o->nb_stream_maps; i++)
123 av_freep(&o->stream_maps[i].linklabel);
124 av_freep(&o->stream_maps);
125 av_freep(&o->meta_data_maps);
126 av_freep(&o->streamid_map);
127 }
128
129 static void init_options(OptionsContext *o)
130 {
131 memset(o, 0, sizeof(*o));
132
133 o->mux_max_delay = 0.7;
134 o->start_time = AV_NOPTS_VALUE;
135 o->recording_time = INT64_MAX;
136 o->limit_filesize = UINT64_MAX;
137 o->chapters_input_file = INT_MAX;
138 o->accurate_seek = 1;
139 }
140
141 /* return a copy of the input with the stream specifiers removed from the keys */
142 static AVDictionary *strip_specifiers(AVDictionary *dict)
143 {
144 AVDictionaryEntry *e = NULL;
145 AVDictionary *ret = NULL;
146
147 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
148 char *p = strchr(e->key, ':');
149
150 if (p)
151 *p = 0;
152 av_dict_set(&ret, e->key, e->value, 0);
153 if (p)
154 *p = ':';
155 }
156 return ret;
157 }
158
159 static double parse_frame_aspect_ratio(const char *arg)
160 {
161 int x = 0, y = 0;
162 double ar = 0;
163 const char *p;
164 char *end;
165
166 p = strchr(arg, ':');
167 if (p) {
168 x = strtol(arg, &end, 10);
169 if (end == p)
170 y = strtol(end + 1, &end, 10);
171 if (x > 0 && y > 0)
172 ar = (double)x / (double)y;
173 } else
174 ar = strtod(arg, NULL);
175
176 if (!ar) {
177 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
178 exit_program(1);
179 }
180 return ar;
181 }
182
183 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
184 {
185 int i;
186
187 printf("Supported hardware acceleration:\n");
188 for (i = 0; i < FF_ARRAY_ELEMS(hwaccels) - 1; i++) {
189 printf("%s\n", hwaccels[i].name);
190 }
191 printf("\n");
192 return 0;
193 }
194
195 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
196 {
197 OptionsContext *o = optctx;
198 return parse_option(o, "codec:a", arg, options);
199 }
200
201 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
202 {
203 OptionsContext *o = optctx;
204 return parse_option(o, "codec:v", arg, options);
205 }
206
207 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
208 {
209 OptionsContext *o = optctx;
210 return parse_option(o, "codec:s", arg, options);
211 }
212
213 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
214 {
215 OptionsContext *o = optctx;
216 return parse_option(o, "codec:d", arg, options);
217 }
218
219 static int opt_map(void *optctx, const char *opt, const char *arg)
220 {
221 OptionsContext *o = optctx;
222 StreamMap *m = NULL;
223 int i, negative = 0, file_idx;
224 int sync_file_idx = -1, sync_stream_idx;
225 char *p, *sync;
226 char *map;
227
228 if (*arg == '-') {
229 negative = 1;
230 arg++;
231 }
232 map = av_strdup(arg);
233 if (!map)
234 return AVERROR(ENOMEM);
235
236 /* parse sync stream first, just pick first matching stream */
237 if (sync = strchr(map, ',')) {
238 *sync = 0;
239 sync_file_idx = strtol(sync + 1, &sync, 0);
240 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
241 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
242 exit_program(1);
243 }
244 if (*sync)
245 sync++;
246 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
247 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
248 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
249 sync_stream_idx = i;
250 break;
251 }
252 if (i == input_files[sync_file_idx]->nb_streams) {
253 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
254 "match any streams.\n", arg);
255 exit_program(1);
256 }
257 }
258
259
260 if (map[0] == '[') {
261 /* this mapping refers to lavfi output */
262 const char *c = map + 1;
263 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
264 m = &o->stream_maps[o->nb_stream_maps - 1];
265 m->linklabel = av_get_token(&c, "]");
266 if (!m->linklabel) {
267 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
268 exit_program(1);
269 }
270 } else {
271 file_idx = strtol(map, &p, 0);
272 if (file_idx >= nb_input_files || file_idx < 0) {
273 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
274 exit_program(1);
275 }
276 if (negative)
277 /* disable some already defined maps */
278 for (i = 0; i < o->nb_stream_maps; i++) {
279 m = &o->stream_maps[i];
280 if (file_idx == m->file_index &&
281 check_stream_specifier(input_files[m->file_index]->ctx,
282 input_files[m->file_index]->ctx->streams[m->stream_index],
283 *p == ':' ? p + 1 : p) > 0)
284 m->disabled = 1;
285 }
286 else
287 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
288 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
289 *p == ':' ? p + 1 : p) <= 0)
290 continue;
291 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
292 m = &o->stream_maps[o->nb_stream_maps - 1];
293
294 m->file_index = file_idx;
295 m->stream_index = i;
296
297 if (sync_file_idx >= 0) {
298 m->sync_file_index = sync_file_idx;
299 m->sync_stream_index = sync_stream_idx;
300 } else {
301 m->sync_file_index = file_idx;
302 m->sync_stream_index = i;
303 }
304 }
305 }
306
307 if (!m) {
308 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
309 exit_program(1);
310 }
311
312 av_freep(&map);
313 return 0;
314 }
315
316 static int opt_attach(void *optctx, const char *opt, const char *arg)
317 {
318 OptionsContext *o = optctx;
319 GROW_ARRAY(o->attachments, o->nb_attachments);
320 o->attachments[o->nb_attachments - 1] = arg;
321 return 0;
322 }
323
324 /**
325 * Parse a metadata specifier passed as 'arg' parameter.
326 * @param arg metadata string to parse
327 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
328 * @param index for type c/p, chapter/program index is written here
329 * @param stream_spec for type s, the stream specifier is written here
330 */
331 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
332 {
333 if (*arg) {
334 *type = *arg;
335 switch (*arg) {
336 case 'g':
337 break;
338 case 's':
339 if (*(++arg) && *arg != ':') {
340 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
341 exit_program(1);
342 }
343 *stream_spec = *arg == ':' ? arg + 1 : "";
344 break;
345 case 'c':
346 case 'p':
347 if (*(++arg) == ':')
348 *index = strtol(++arg, NULL, 0);
349 break;
350 default:
351 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
352 exit_program(1);
353 }
354 } else
355 *type = 'g';
356 }
357
358 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
359 {
360 AVDictionary **meta_in = NULL;
361 AVDictionary **meta_out;
362 int i, ret = 0;
363 char type_in, type_out;
364 const char *istream_spec = NULL, *ostream_spec = NULL;
365 int idx_in = 0, idx_out = 0;
366
367 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
368 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
369
370 if (type_in == 'g' || type_out == 'g')
371 o->metadata_global_manual = 1;
372 if (type_in == 's' || type_out == 's')
373 o->metadata_streams_manual = 1;
374 if (type_in == 'c' || type_out == 'c')
375 o->metadata_chapters_manual = 1;
376
377 /* ic is NULL when just disabling automatic mappings */
378 if (!ic)
379 return 0;
380
381 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
382 if ((index) < 0 || (index) >= (nb_elems)) {\
383 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
384 (desc), (index));\
385 exit_program(1);\
386 }
387
388 #define SET_DICT(type, meta, context, index)\
389 switch (type) {\
390 case 'g':\
391 meta = &context->metadata;\
392 break;\
393 case 'c':\
394 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
395 meta = &context->chapters[index]->metadata;\
396 break;\
397 case 'p':\
398 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
399 meta = &context->programs[index]->metadata;\
400 break;\
401 case 's':\
402 break; /* handled separately below */ \
403 default: av_assert0(0);\
404 }\
405
406 SET_DICT(type_in, meta_in, ic, idx_in);
407 SET_DICT(type_out, meta_out, oc, idx_out);
408
409 /* for input streams choose first matching stream */
410 if (type_in == 's') {
411 for (i = 0; i < ic->nb_streams; i++) {
412 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
413 meta_in = &ic->streams[i]->metadata;
414 break;
415 } else if (ret < 0)
416 exit_program(1);
417 }
418 if (!meta_in) {
419 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
420 exit_program(1);
421 }
422 }
423
424 if (type_out == 's') {
425 for (i = 0; i < oc->nb_streams; i++) {
426 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
427 meta_out = &oc->streams[i]->metadata;
428 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
429 } else if (ret < 0)
430 exit_program(1);
431 }
432 } else
433 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
434
435 return 0;
436 }
437
438 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
439 {
440 const AVCodecDescriptor *desc;
441 const char *codec_string = encoder ? "encoder" : "decoder";
442 AVCodec *codec;
443
444 codec = encoder ?
445 avcodec_find_encoder_by_name(name) :
446 avcodec_find_decoder_by_name(name);
447
448 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
449 codec = encoder ? avcodec_find_encoder(desc->id) :
450 avcodec_find_decoder(desc->id);
451 if (codec)
452 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
453 codec_string, codec->name, desc->name);
454 }
455
456 if (!codec) {
457 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
458 exit_program(1);
459 }
460 if (codec->type != type) {
461 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
462 exit_program(1);
463 }
464 return codec;
465 }
466
467 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
468 {
469 char *codec_name = NULL;
470
471 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
472 if (codec_name) {
473 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
474 st->codec->codec_id = codec->id;
475 return codec;
476 } else
477 return avcodec_find_decoder(st->codec->codec_id);
478 }
479
480 /* Add all the streams from the given input file to the global
481 * list of input streams. */
482 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
483 {
484 int i, ret;
485
486 for (i = 0; i < ic->nb_streams; i++) {
487 AVStream *st = ic->streams[i];
488 AVCodecContext *dec = st->codec;
489 InputStream *ist = av_mallocz(sizeof(*ist));
490 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
491 char *codec_tag = NULL;
492 char *next;
493
494 if (!ist)
495 exit_program(1);
496
497 GROW_ARRAY(input_streams, nb_input_streams);
498 input_streams[nb_input_streams - 1] = ist;
499
500 ist->st = st;
501 ist->file_index = nb_input_files;
502 ist->discard = 1;
503 st->discard = AVDISCARD_ALL;
504 ist->nb_samples = 0;
505 ist->min_pts = INT64_MAX;
506 ist->max_pts = INT64_MIN;
507
508 ist->ts_scale = 1.0;
509 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
510
511 ist->autorotate = 1;
512 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
513
514 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
515 if (codec_tag) {
516 uint32_t tag = strtol(codec_tag, &next, 0);
517 if (*next)
518 tag = AV_RL32(codec_tag);
519 st->codec->codec_tag = tag;
520 }
521
522 ist->dec = choose_decoder(o, ic, st);
523 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
524
525 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
526 if (!ist->dec_ctx) {
527 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
528 exit_program(1);
529 }
530
531 ret = avcodec_copy_context(ist->dec_ctx, dec);
532 if (ret < 0) {
533 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
534 exit_program(1);
535 }
536
537 switch (dec->codec_type) {
538 case AVMEDIA_TYPE_VIDEO:
539 ist->resample_height = ist->dec_ctx->height;
540 ist->resample_width = ist->dec_ctx->width;
541 ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
542
543 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
544 if (framerate && av_parse_video_rate(&ist->framerate,
545 framerate) < 0) {
546 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
547 framerate);
548 exit_program(1);
549 }
550
551 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
552 if (hwaccel) {
553 if (!strcmp(hwaccel, "none"))
554 ist->hwaccel_id = HWACCEL_NONE;
555 else if (!strcmp(hwaccel, "auto"))
556 ist->hwaccel_id = HWACCEL_AUTO;
557 else {
558 int i;
559 for (i = 0; hwaccels[i].name; i++) {
560 if (!strcmp(hwaccels[i].name, hwaccel)) {
561 ist->hwaccel_id = hwaccels[i].id;
562 break;
563 }
564 }
565
566 if (!ist->hwaccel_id) {
567 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
568 hwaccel);
569 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
570 for (i = 0; hwaccels[i].name; i++)
571 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
572 av_log(NULL, AV_LOG_FATAL, "\n");
573 exit_program(1);
574 }
575 }
576 }
577
578 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
579 if (hwaccel_device) {
580 ist->hwaccel_device = av_strdup(hwaccel_device);
581 if (!ist->hwaccel_device)
582 exit_program(1);
583 }
584 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
585
586 break;
587 case AVMEDIA_TYPE_AUDIO:
588 guess_input_channel_layout(ist);
589
590 ist->resample_sample_fmt = ist->dec_ctx->sample_fmt;
591 ist->resample_sample_rate = ist->dec_ctx->sample_rate;
592 ist->resample_channels = ist->dec_ctx->channels;
593 ist->resample_channel_layout = ist->dec_ctx->channel_layout;
594
595 break;
596 case AVMEDIA_TYPE_DATA:
597 case AVMEDIA_TYPE_SUBTITLE:
598 case AVMEDIA_TYPE_ATTACHMENT:
599 case AVMEDIA_TYPE_UNKNOWN:
600 break;
601 default:
602 abort();
603 }
604 }
605 }
606
607 static void assert_file_overwrite(const char *filename)
608 {
609 if (file_overwrite && file_skip) {
610 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
611 exit_program(1);
612 }
613
614 if (!file_overwrite &&
615 (!strchr(filename, ':') || filename[1] == ':' ||
616 av_strstart(filename, "file:", NULL))) {
617 if (avio_check(filename, 0) == 0) {
618 if (!using_stdin && !file_skip) {
619 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
620 fflush(stderr);
621 if (!read_yesno()) {
622 fprintf(stderr, "Not overwriting - exiting\n");
623 exit_program(1);
624 }
625 }
626 else {
627 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
628 exit_program(1);
629 }
630 }
631 }
632 }
633
634 static void dump_attachment(AVStream *st, const char *filename)
635 {
636 int ret;
637 AVIOContext *out = NULL;
638 AVDictionaryEntry *e;
639
640 if (!st->codec->extradata_size) {
641 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
642 nb_input_files - 1, st->index);
643 return;
644 }
645 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
646 filename = e->value;
647 if (!*filename) {
648 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
649 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
650 exit_program(1);
651 }
652
653 assert_file_overwrite(filename);
654
655 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
656 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
657 filename);
658 exit_program(1);
659 }
660
661 avio_write(out, st->codec->extradata, st->codec->extradata_size);
662 avio_flush(out);
663 avio_close(out);
664 }
665
666 static int open_input_file(OptionsContext *o, const char *filename)
667 {
668 InputFile *f;
669 AVFormatContext *ic;
670 AVInputFormat *file_iformat = NULL;
671 int err, i, ret;
672 int64_t timestamp;
673 uint8_t buf[128];
674 AVDictionary **opts;
675 AVDictionary *unused_opts = NULL;
676 AVDictionaryEntry *e = NULL;
677 int orig_nb_streams; // number of streams before avformat_find_stream_info
678
679 if (o->format) {
680 if (!(file_iformat = av_find_input_format(o->format))) {
681 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
682 exit_program(1);
683 }
684 }
685
686 if (!strcmp(filename, "-"))
687 filename = "pipe:";
688
689 using_stdin |= !strncmp(filename, "pipe:", 5) ||
690 !strcmp(filename, "/dev/stdin");
691
692 /* get default parameters from command line */
693 ic = avformat_alloc_context();
694 if (!ic) {
695 print_error(filename, AVERROR(ENOMEM));
696 exit_program(1);
697 }
698 if (o->nb_audio_sample_rate) {
699 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
700 av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
701 }
702 if (o->nb_audio_channels) {
703 /* because we set audio_channels based on both the "ac" and
704 * "channel_layout" options, we need to check that the specified
705 * demuxer actually has the "channels" option before setting it */
706 if (file_iformat && file_iformat->priv_class &&
707 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
708 AV_OPT_SEARCH_FAKE_OBJ)) {
709 snprintf(buf, sizeof(buf), "%d",
710 o->audio_channels[o->nb_audio_channels - 1].u.i);
711 av_dict_set(&o->g->format_opts, "channels", buf, 0);
712 }
713 }
714 if (o->nb_frame_rates) {
715 /* set the format-level framerate option;
716 * this is important for video grabbers, e.g. x11 */
717 if (file_iformat && file_iformat->priv_class &&
718 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
719 AV_OPT_SEARCH_FAKE_OBJ)) {
720 av_dict_set(&o->g->format_opts, "framerate",
721 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
722 }
723 }
724 if (o->nb_frame_sizes) {
725 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
726 }
727 if (o->nb_frame_pix_fmts)
728 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
729
730 ic->flags |= AVFMT_FLAG_NONBLOCK;
731 ic->interrupt_callback = int_cb;
732
733 /* open the input file with generic libav function */
734 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
735 if (err < 0) {
736 print_error(filename, err);
737 exit_program(1);
738 }
739 assert_avoptions(o->g->format_opts);
740
741 /* apply forced codec ids */
742 for (i = 0; i < ic->nb_streams; i++)
743 choose_decoder(o, ic, ic->streams[i]);
744
745 /* Set AVCodecContext options for avformat_find_stream_info */
746 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
747 orig_nb_streams = ic->nb_streams;
748
749 /* If not enough info to get the stream parameters, we decode the
750 first frames to get it. (used in mpeg case for example) */
751 ret = avformat_find_stream_info(ic, opts);
752 if (ret < 0) {
753 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
754 avformat_close_input(&ic);
755 exit_program(1);
756 }
757
758 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
759 /* add the stream start time */
760 if (ic->start_time != AV_NOPTS_VALUE)
761 timestamp += ic->start_time;
762
763 /* if seeking requested, we execute it */
764 if (o->start_time != AV_NOPTS_VALUE) {
765 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
766 if (ret < 0) {
767 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
768 filename, (double)timestamp / AV_TIME_BASE);
769 }
770 }
771
772 /* update the current parameters so that they match the one of the input stream */
773 add_input_streams(o, ic);
774
775 /* dump the file content */
776 av_dump_format(ic, nb_input_files, filename, 0);
777
778 GROW_ARRAY(input_files, nb_input_files);
779 f = av_mallocz(sizeof(*f));
780 if (!f)
781 exit_program(1);
782 input_files[nb_input_files - 1] = f;
783
784 f->ctx = ic;
785 f->ist_index = nb_input_streams - ic->nb_streams;
786 f->start_time = o->start_time;
787 f->recording_time = o->recording_time;
788 f->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
789 f->nb_streams = ic->nb_streams;
790 f->rate_emu = o->rate_emu;
791 f->accurate_seek = o->accurate_seek;
792 f->loop = o->loop;
793 f->duration = 0;
794 f->time_base = (AVRational){ 1, 1 };
795
796 /* check if all codec options have been used */
797 unused_opts = strip_specifiers(o->g->codec_opts);
798 for (i = f->ist_index; i < nb_input_streams; i++) {
799 e = NULL;
800 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
801 AV_DICT_IGNORE_SUFFIX)))
802 av_dict_set(&unused_opts, e->key, NULL, 0);
803 }
804
805 e = NULL;
806 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
807 const AVClass *class = avcodec_get_class();
808 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
809 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
810 if (!option)
811 continue;
812 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
813 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
814 "input file #%d (%s) is not a decoding option.\n", e->key,
815 option->help ? option->help : "", nb_input_files - 1,
816 filename);
817 exit_program(1);
818 }
819
820 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
821 "input file #%d (%s) has not been used for any stream. The most "
822 "likely reason is either wrong type (e.g. a video option with "
823 "no video streams) or that it is a private option of some decoder "
824 "which was not actually used for any stream.\n", e->key,
825 option->help ? option->help : "", nb_input_files - 1, filename);
826 }
827 av_dict_free(&unused_opts);
828
829 for (i = 0; i < o->nb_dump_attachment; i++) {
830 int j;
831
832 for (j = 0; j < ic->nb_streams; j++) {
833 AVStream *st = ic->streams[j];
834
835 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
836 dump_attachment(st, o->dump_attachment[i].u.str);
837 }
838 }
839
840 for (i = 0; i < orig_nb_streams; i++)
841 av_dict_free(&opts[i]);
842 av_freep(&opts);
843
844 return 0;
845 }
846
847 static uint8_t *get_line(AVIOContext *s)
848 {
849 AVIOContext *line;
850 uint8_t *buf;
851 char c;
852
853 if (avio_open_dyn_buf(&line) < 0) {
854 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
855 exit_program(1);
856 }
857
858 while ((c = avio_r8(s)) && c != '\n')
859 avio_w8(line, c);
860 avio_w8(line, 0);
861 avio_close_dyn_buf(line, &buf);
862
863 return buf;
864 }
865
866 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
867 {
868 int i, ret = -1;
869 char filename[1000];
870 const char *base[3] = { getenv("AVCONV_DATADIR"),
871 getenv("HOME"),
872 AVCONV_DATADIR,
873 };
874
875 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
876 if (!base[i])
877 continue;
878 if (codec_name) {
879 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
880 i != 1 ? "" : "/.avconv", codec_name, preset_name);
881 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
882 }
883 if (ret < 0) {
884 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
885 i != 1 ? "" : "/.avconv", preset_name);
886 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
887 }
888 }
889 return ret;
890 }
891
892 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
893 {
894 char *codec_name = NULL;
895
896 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
897 if (!codec_name) {
898 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
899 NULL, ost->st->codec->codec_type);
900 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
901 } else if (!strcmp(codec_name, "copy"))
902 ost->stream_copy = 1;
903 else {
904 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
905 ost->st->codec->codec_id = ost->enc->id;
906 }
907 }
908
909 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
910 {
911 OutputStream *ost;
912 AVStream *st = avformat_new_stream(oc, NULL);
913 int idx = oc->nb_streams - 1, ret = 0;
914 char *bsf = NULL, *next, *codec_tag = NULL;
915 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
916 double qscale = -1;
917
918 if (!st) {
919 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
920 exit_program(1);
921 }
922
923 if (oc->nb_streams - 1 < o->nb_streamid_map)
924 st->id = o->streamid_map[oc->nb_streams - 1];
925
926 GROW_ARRAY(output_streams, nb_output_streams);
927 if (!(ost = av_mallocz(sizeof(*ost))))
928 exit_program(1);
929 output_streams[nb_output_streams - 1] = ost;
930
931 ost->file_index = nb_output_files - 1;
932 ost->index = idx;
933 ost->st = st;
934 st->codec->codec_type = type;
935 choose_encoder(o, oc, ost);
936
937 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
938 if (!ost->enc_ctx) {
939 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
940 exit_program(1);
941 }
942 ost->enc_ctx->codec_type = type;
943
944 if (ost->enc) {
945 AVIOContext *s = NULL;
946 char *buf = NULL, *arg = NULL, *preset = NULL;
947
948 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
949
950 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
951 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
952 do {
953 buf = get_line(s);
954 if (!buf[0] || buf[0] == '#') {
955 av_free(buf);
956 continue;
957 }
958 if (!(arg = strchr(buf, '='))) {
959 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
960 exit_program(1);
961 }
962 *arg++ = 0;
963 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
964 av_free(buf);
965 } while (!s->eof_reached);
966 avio_close(s);
967 }
968 if (ret) {
969 av_log(NULL, AV_LOG_FATAL,
970 "Preset %s specified for stream %d:%d, but could not be opened.\n",
971 preset, ost->file_index, ost->index);
972 exit_program(1);
973 }
974 } else {
975 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
976 }
977
978 ost->max_frames = INT64_MAX;
979 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
980
981 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
982 while (bsf) {
983 if (next = strchr(bsf, ','))
984 *next++ = 0;
985 if (!(bsfc = av_bitstream_filter_init(bsf))) {
986 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
987 exit_program(1);
988 }
989 if (bsfc_prev)
990 bsfc_prev->next = bsfc;
991 else
992 ost->bitstream_filters = bsfc;
993
994 bsfc_prev = bsfc;
995 bsf = next;
996 }
997
998 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
999 if (codec_tag) {
1000 uint32_t tag = strtol(codec_tag, &next, 0);
1001 if (*next)
1002 tag = AV_RL32(codec_tag);
1003 ost->enc_ctx->codec_tag = tag;
1004 }
1005
1006 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1007 if (qscale >= 0) {
1008 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1009 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1010 }
1011
1012 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1013 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1014
1015 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1016
1017 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1018
1019 ost->pix_fmts[0] = ost->pix_fmts[1] = AV_PIX_FMT_NONE;
1020 ost->last_mux_dts = AV_NOPTS_VALUE;
1021
1022 return ost;
1023 }
1024
1025 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1026 {
1027 int i;
1028 const char *p = str;
1029 for (i = 0;; i++) {
1030 dest[i] = atoi(p);
1031 if (i == 63)
1032 break;
1033 p = strchr(p, ',');
1034 if (!p) {
1035 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1036 exit_program(1);
1037 }
1038 p++;
1039 }
1040 }
1041
1042 /* read file contents into a string */
1043 static uint8_t *read_file(const char *filename)
1044 {
1045 AVIOContext *pb = NULL;
1046 AVIOContext *dyn_buf = NULL;
1047 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1048 uint8_t buf[1024], *str;
1049
1050 if (ret < 0) {
1051 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1052 return NULL;
1053 }
1054
1055 ret = avio_open_dyn_buf(&dyn_buf);
1056 if (ret < 0) {
1057 avio_closep(&pb);
1058 return NULL;
1059 }
1060 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1061 avio_write(dyn_buf, buf, ret);
1062 avio_w8(dyn_buf, 0);
1063 avio_closep(&pb);
1064
1065 ret = avio_close_dyn_buf(dyn_buf, &str);
1066 if (ret < 0)
1067 return NULL;
1068 return str;
1069 }
1070
1071 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1072 OutputStream *ost)
1073 {
1074 AVStream *st = ost->st;
1075 char *filter = NULL, *filter_script = NULL;
1076
1077 MATCH_PER_STREAM_OPT(filter_scripts, str, filter_script, oc, st);
1078 MATCH_PER_STREAM_OPT(filters, str, filter, oc, st);
1079
1080 if (filter_script && filter) {
1081 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1082 "output stream #%d:%d.\n", nb_output_files, st->index);
1083 exit_program(1);
1084 }
1085
1086 if (filter_script)
1087 return read_file(filter_script);
1088 else if (filter)
1089 return av_strdup(filter);
1090
1091 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1092 "null" : "anull");
1093 }
1094
1095 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
1096 {
1097 AVStream *st;
1098 OutputStream *ost;
1099 AVCodecContext *video_enc;
1100 char *frame_aspect_ratio = NULL;
1101
1102 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
1103 st = ost->st;
1104 video_enc = ost->enc_ctx;
1105
1106 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1107 if (frame_aspect_ratio)
1108 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
1109
1110 if (!ost->stream_copy) {
1111 const char *p = NULL;
1112 char *frame_rate = NULL, *frame_size = NULL;
1113 char *frame_pix_fmt = NULL;
1114 char *intra_matrix = NULL, *inter_matrix = NULL;
1115 int do_pass = 0;
1116 int i;
1117
1118 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1119 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1120 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1121 exit_program(1);
1122 }
1123
1124 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1125 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1126 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1127 exit_program(1);
1128 }
1129
1130 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1131 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1132 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1133 exit_program(1);
1134 }
1135 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1136
1137 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1138 if (intra_matrix) {
1139 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1140 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1141 exit_program(1);
1142 }
1143 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1144 }
1145 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1146 if (inter_matrix) {
1147 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1148 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1149 exit_program(1);
1150 }
1151 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1152 }
1153
1154 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1155 for (i = 0; p; i++) {
1156 int start, end, q;
1157 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1158 if (e != 3) {
1159 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1160 exit_program(1);
1161 }
1162 video_enc->rc_override =
1163 av_realloc(video_enc->rc_override,
1164 sizeof(RcOverride) * (i + 1));
1165 if (!video_enc->rc_override) {
1166 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1167 exit_program(1);
1168 }
1169 video_enc->rc_override[i].start_frame = start;
1170 video_enc->rc_override[i].end_frame = end;
1171 if (q > 0) {
1172 video_enc->rc_override[i].qscale = q;
1173 video_enc->rc_override[i].quality_factor = 1.0;
1174 }
1175 else {
1176 video_enc->rc_override[i].qscale = 0;
1177 video_enc->rc_override[i].quality_factor = -q/100.0;
1178 }
1179 p = strchr(p, '/');
1180 if (p) p++;
1181 }
1182 video_enc->rc_override_count = i;
1183 video_enc->intra_dc_precision = intra_dc_precision - 8;
1184
1185 /* two pass mode */
1186 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1187 if (do_pass) {
1188 if (do_pass == 1) {
1189 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1190 } else {
1191 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1192 }
1193 }
1194
1195 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1196 if (ost->logfile_prefix &&
1197 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1198 exit_program(1);
1199
1200 if (do_pass) {
1201 char logfilename[1024];
1202 FILE *f;
1203
1204 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1205 ost->logfile_prefix ? ost->logfile_prefix :
1206 DEFAULT_PASS_LOGFILENAME_PREFIX,
1207 i);
1208 if (!strcmp(ost->enc->name, "libx264")) {
1209 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1210 } else {
1211 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1212 f = fopen(logfilename, "wb");
1213 if (!f) {
1214 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
1215 logfilename, strerror(errno));
1216 exit_program(1);
1217 }
1218 ost->logfile = f;
1219 } else {
1220 char *logbuffer = read_file(logfilename);
1221
1222 if (!logbuffer) {
1223 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1224 logfilename);
1225 exit_program(1);
1226 }
1227 video_enc->stats_in = logbuffer;
1228 }
1229 }
1230 }
1231
1232 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1233 if (ost->forced_keyframes)
1234 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1235
1236 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1237
1238 ost->top_field_first = -1;
1239 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1240
1241
1242 ost->avfilter = get_ost_filters(o, oc, ost);
1243 if (!ost->avfilter)
1244 exit_program(1);
1245 } else {
1246 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1247 }
1248
1249 return ost;
1250 }
1251
1252 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
1253 {
1254 AVStream *st;
1255 OutputStream *ost;
1256 AVCodecContext *audio_enc;
1257
1258 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
1259 st = ost->st;
1260
1261 audio_enc = ost->enc_ctx;
1262 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1263
1264 if (!ost->stream_copy) {
1265 char *sample_fmt = NULL;
1266
1267 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1268
1269 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1270 if (sample_fmt &&
1271 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1272 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1273 exit_program(1);
1274 }
1275
1276 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1277
1278 ost->avfilter = get_ost_filters(o, oc, ost);
1279 if (!ost->avfilter)
1280 exit_program(1);
1281 }
1282
1283 return ost;
1284 }
1285
1286 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
1287 {
1288 OutputStream *ost;
1289
1290 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
1291 if (!ost->stream_copy) {
1292 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1293 exit_program(1);
1294 }
1295
1296 return ost;
1297 }
1298
1299 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
1300 {
1301 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
1302 ost->stream_copy = 1;
1303 ost->finished = 1;
1304 return ost;
1305 }
1306
1307 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
1308 {
1309 OutputStream *ost;
1310 AVCodecContext *subtitle_enc;
1311
1312 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
1313 subtitle_enc = ost->enc_ctx;
1314
1315 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1316
1317 return ost;
1318 }
1319
1320 /* arg format is "output-stream-index:streamid-value". */
1321 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1322 {
1323 OptionsContext *o = optctx;
1324 int idx;
1325 char *p;
1326 char idx_str[16];
1327
1328 av_strlcpy(idx_str, arg, sizeof(idx_str));
1329 p = strchr(idx_str, ':');
1330 if (!p) {
1331 av_log(NULL, AV_LOG_FATAL,
1332 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1333 arg, opt);
1334 exit_program(1);
1335 }
1336 *p++ = '\0';
1337 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
1338 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1339 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1340 return 0;
1341 }
1342
1343 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1344 {
1345 AVFormatContext *is = ifile->ctx;
1346 AVFormatContext *os = ofile->ctx;
1347 AVChapter **tmp;
1348 int i;
1349
1350 tmp = av_realloc(os->chapters, sizeof(*os->chapters) * (is->nb_chapters + os->nb_chapters));
1351 if (!tmp)
1352 return AVERROR(ENOMEM);
1353 os->chapters = tmp;
1354
1355 for (i = 0; i < is->nb_chapters; i++) {
1356 AVChapter *in_ch = is->chapters[i], *out_ch;
1357 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1358 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1359 AV_TIME_BASE_Q, in_ch->time_base);
1360 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1361 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1362
1363
1364 if (in_ch->end < ts_off)
1365 continue;
1366 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1367 break;
1368
1369 out_ch = av_mallocz(sizeof(AVChapter));
1370 if (!out_ch)
1371 return AVERROR(ENOMEM);
1372
1373 out_ch->id = in_ch->id;
1374 out_ch->time_base = in_ch->time_base;
1375 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1376 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1377
1378 if (copy_metadata)
1379 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1380
1381 os->chapters[os->nb_chapters++] = out_ch;
1382 }
1383 return 0;
1384 }
1385
1386 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1387 AVFormatContext *oc)
1388 {
1389 OutputStream *ost;
1390
1391 switch (ofilter->type) {
1392 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1393 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1394 default:
1395 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1396 "currently.\n");
1397 exit_program(1);
1398 }
1399
1400 ost->source_index = -1;
1401 ost->filter = ofilter;
1402
1403 ofilter->ost = ost;
1404
1405 if (ost->stream_copy) {
1406 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1407 "which is fed from a complex filtergraph. Filtering and streamcopy "
1408 "cannot be used together.\n", ost->file_index, ost->index);
1409 exit_program(1);
1410 }
1411
1412 avfilter_inout_free(&ofilter->out_tmp);
1413 }
1414
1415 static int init_complex_filters(void)
1416 {
1417 int i, ret = 0;
1418
1419 for (i = 0; i < nb_filtergraphs; i++) {
1420 ret = init_complex_filtergraph(filtergraphs[i]);
1421 if (ret < 0)
1422 return ret;
1423 }
1424 return 0;
1425 }
1426
1427 static int configure_complex_filters(void)
1428 {
1429 int i, ret = 0;
1430
1431 for (i = 0; i < nb_filtergraphs; i++)
1432 if (!filtergraphs[i]->graph &&
1433 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1434 return ret;
1435 return 0;
1436 }
1437
1438 static int open_output_file(OptionsContext *o, const char *filename)
1439 {
1440 AVFormatContext *oc;
1441 int i, j, err;
1442 AVOutputFormat *file_oformat;
1443 OutputFile *of;
1444 OutputStream *ost;
1445 InputStream *ist;
1446 AVDictionary *unused_opts = NULL;
1447 AVDictionaryEntry *e = NULL;
1448
1449 GROW_ARRAY(output_files, nb_output_files);
1450 of = av_mallocz(sizeof(*of));
1451 if (!of)
1452 exit_program(1);
1453 output_files[nb_output_files - 1] = of;
1454
1455 of->ost_index = nb_output_streams;
1456 of->recording_time = o->recording_time;
1457 of->start_time = o->start_time;
1458 of->limit_filesize = o->limit_filesize;
1459 of->shortest = o->shortest;
1460 av_dict_copy(&of->opts, o->g->format_opts, 0);
1461
1462 if (!strcmp(filename, "-"))
1463 filename = "pipe:";
1464
1465 oc = avformat_alloc_context();
1466 if (!oc) {
1467 print_error(filename, AVERROR(ENOMEM));
1468 exit_program(1);
1469 }
1470 of->ctx = oc;
1471 if (o->recording_time != INT64_MAX)
1472 oc->duration = o->recording_time;
1473
1474 if (o->format) {
1475 file_oformat = av_guess_format(o->format, NULL, NULL);
1476 if (!file_oformat) {
1477 av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
1478 exit_program(1);
1479 }
1480 } else {
1481 file_oformat = av_guess_format(NULL, filename, NULL);
1482 if (!file_oformat) {
1483 av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
1484 filename);
1485 exit_program(1);
1486 }
1487 }
1488
1489 oc->oformat = file_oformat;
1490 oc->interrupt_callback = int_cb;
1491 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
1492
1493 /* create streams for all unlabeled output pads */
1494 for (i = 0; i < nb_filtergraphs; i++) {
1495 FilterGraph *fg = filtergraphs[i];
1496 for (j = 0; j < fg->nb_outputs; j++) {
1497 OutputFilter *ofilter = fg->outputs[j];
1498
1499 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1500 continue;
1501
1502 switch (ofilter->type) {
1503 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1504 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1505 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1506 }
1507 init_output_filter(ofilter, o, oc);
1508 }
1509 }
1510
1511 if (!o->nb_stream_maps) {
1512 /* pick the "best" stream of each type */
1513 #define NEW_STREAM(type, index)\
1514 if (index >= 0) {\
1515 ost = new_ ## type ## _stream(o, oc);\
1516 ost->source_index = index;\
1517 ost->sync_ist = input_streams[index];\
1518 input_streams[index]->discard = 0;\
1519 input_streams[index]->st->discard = AVDISCARD_NONE;\
1520 }
1521
1522 /* video: highest resolution */
1523 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1524 int area = 0, idx = -1;
1525 for (i = 0; i < nb_input_streams; i++) {
1526 ist = input_streams[i];
1527 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1528 ist->st->codec->width * ist->st->codec->height > area) {
1529 area = ist->st->codec->width * ist->st->codec->height;
1530 idx = i;
1531 }
1532 }
1533 NEW_STREAM(video, idx);
1534 }
1535
1536 /* audio: most channels */
1537 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1538 int channels = 0, idx = -1;
1539 for (i = 0; i < nb_input_streams; i++) {
1540 ist = input_streams[i];
1541 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1542 ist->st->codec->channels > channels) {
1543 channels = ist->st->codec->channels;
1544 idx = i;
1545 }
1546 }
1547 NEW_STREAM(audio, idx);
1548 }
1549
1550 /* subtitles: pick first */
1551 if (!o->subtitle_disable && oc->oformat->subtitle_codec != AV_CODEC_ID_NONE) {
1552 for (i = 0; i < nb_input_streams; i++)
1553 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1554 NEW_STREAM(subtitle, i);
1555 break;
1556 }
1557 }
1558 /* do something with data? */
1559 } else {
1560 for (i = 0; i < o->nb_stream_maps; i++) {
1561 StreamMap *map = &o->stream_maps[i];
1562
1563 if (map->disabled)
1564 continue;
1565
1566 if (map->linklabel) {
1567 FilterGraph *fg;
1568 OutputFilter *ofilter = NULL;
1569 int j, k;
1570
1571 for (j = 0; j < nb_filtergraphs; j++) {
1572 fg = filtergraphs[j];
1573 for (k = 0; k < fg->nb_outputs; k++) {
1574 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1575 if (out && !strcmp(out->name, map->linklabel)) {
1576 ofilter = fg->outputs[k];
1577 goto loop_end;
1578 }
1579 }
1580 }
1581 loop_end:
1582 if (!ofilter) {
1583 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1584 "in any defined filter graph.\n", map->linklabel);
1585 exit_program(1);
1586 }
1587 init_output_filter(ofilter, o, oc);
1588 } else {
1589 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1590 switch (ist->st->codec->codec_type) {
1591 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1592 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1593 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
1594 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
1595 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
1596 default:
1597 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1598 map->file_index, map->stream_index);
1599 exit_program(1);
1600 }
1601
1602 ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
1603 ost->sync_ist = input_streams[input_files[map->sync_file_index]->ist_index +
1604 map->sync_stream_index];
1605 ist->discard = 0;
1606 ist->st->discard = AVDISCARD_NONE;
1607 }
1608 }
1609 }
1610
1611 /* handle attached files */
1612 for (i = 0; i < o->nb_attachments; i++) {
1613 AVIOContext *pb;
1614 uint8_t *attachment;
1615 const char *p;
1616 int64_t len;
1617
1618 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1619 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1620 o->attachments[i]);
1621 exit_program(1);
1622 }
1623 if ((len = avio_size(pb)) <= 0) {
1624 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1625 o->attachments[i]);
1626 exit_program(1);
1627 }
1628 if (!(attachment = av_malloc(len))) {
1629 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1630 o->attachments[i]);
1631 exit_program(1);
1632 }
1633 avio_read(pb, attachment, len);
1634
1635 ost = new_attachment_stream(o, oc);
1636 ost->stream_copy = 0;
1637 ost->source_index = -1;
1638 ost->attachment_filename = o->attachments[i];
1639 ost->st->codec->extradata = attachment;
1640 ost->st->codec->extradata_size = len;
1641
1642 p = strrchr(o->attachments[i], '/');
1643 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1644 avio_close(pb);
1645 }
1646
1647 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
1648 av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
1649 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
1650 exit_program(1);
1651 }
1652
1653 /* check if all codec options have been used */
1654 unused_opts = strip_specifiers(o->g->codec_opts);
1655 for (i = of->ost_index; i < nb_output_streams; i++) {
1656 e = NULL;
1657 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
1658 AV_DICT_IGNORE_SUFFIX)))
1659 av_dict_set(&unused_opts, e->key, NULL, 0);
1660 }
1661
1662 e = NULL;
1663 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1664 const AVClass *class = avcodec_get_class();
1665 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1666 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1667 if (!option)
1668 continue;
1669 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1670 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1671 "output file #%d (%s) is not an encoding option.\n", e->key,
1672 option->help ? option->help : "", nb_output_files - 1,
1673 filename);
1674 exit_program(1);
1675 }
1676
1677 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1678 "output file #%d (%s) has not been used for any stream. The most "
1679 "likely reason is either wrong type (e.g. a video option with "
1680 "no video streams) or that it is a private option of some encoder "
1681 "which was not actually used for any stream.\n", e->key,
1682 option->help ? option->help : "", nb_output_files - 1, filename);
1683 }
1684 av_dict_free(&unused_opts);
1685
1686 /* set the encoding/decoding_needed flags */
1687 for (i = of->ost_index; i < nb_output_streams; i++) {
1688 OutputStream *ost = output_streams[i];
1689
1690 ost->encoding_needed = !ost->stream_copy;
1691 if (ost->encoding_needed && ost->source_index >= 0) {
1692 InputStream *ist = input_streams[ost->source_index];
1693 ist->decoding_needed = 1;
1694 }
1695 }
1696
1697 /* check filename in case of an image number is expected */
1698 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1699 if (!av_filename_number_test(oc->filename)) {
1700 print_error(oc->filename, AVERROR(EINVAL));
1701 exit_program(1);
1702 }
1703 }
1704
1705 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1706 /* test if it already exists to avoid losing precious files */
1707 assert_file_overwrite(filename);
1708
1709 /* open the file */
1710 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1711 &oc->interrupt_callback,
1712 &of->opts)) < 0) {
1713 print_error(filename, err);
1714 exit_program(1);
1715 }
1716 }
1717
1718 if (o->mux_preload) {
1719 uint8_t buf[64];
1720 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1721 av_dict_set(&of->opts, "preload", buf, 0);
1722 }
1723 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1724 oc->flags |= AVFMT_FLAG_NONBLOCK;
1725
1726 /* copy metadata */
1727 for (i = 0; i < o->nb_metadata_map; i++) {
1728 char *p;
1729 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1730
1731 if (in_file_index >= nb_input_files) {
1732 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1733 exit_program(1);
1734 }
1735 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1736 in_file_index >= 0 ?
1737 input_files[in_file_index]->ctx : NULL, o);
1738 }
1739
1740 /* copy chapters */
1741 if (o->chapters_input_file >= nb_input_files) {
1742 if (o->chapters_input_file == INT_MAX) {
1743 /* copy chapters from the first input file that has them*/
1744 o->chapters_input_file = -1;
1745 for (i = 0; i < nb_input_files; i++)
1746 if (input_files[i]->ctx->nb_chapters) {
1747 o->chapters_input_file = i;
1748 break;
1749 }
1750 } else {
1751 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1752 o->chapters_input_file);
1753 exit_program(1);
1754 }
1755 }
1756 if (o->chapters_input_file >= 0)
1757 copy_chapters(input_files[o->chapters_input_file], of,
1758 !o->metadata_chapters_manual);
1759
1760 /* copy global metadata by default */
1761 if (!o->metadata_global_manual && nb_input_files)
1762 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1763 AV_DICT_DONT_OVERWRITE);
1764 if (!o->metadata_streams_manual)
1765 for (i = of->ost_index; i < nb_output_streams; i++) {
1766 InputStream *ist;
1767 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1768 continue;
1769 ist = input_streams[output_streams[i]->source_index];
1770 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1771 }
1772
1773 /* process manually set metadata */
1774 for (i = 0; i < o->nb_metadata; i++) {
1775 AVDictionary **m;
1776 char type, *val;
1777 const char *stream_spec;
1778 int index = 0, j, ret;
1779
1780 val = strchr(o->metadata[i].u.str, '=');
1781 if (!val) {
1782 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1783 o->metadata[i].u.str);
1784 exit_program(1);
1785 }
1786 *val++ = 0;
1787
1788 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1789 if (type == 's') {
1790 for (j = 0; j < oc->nb_streams; j++) {
1791 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1792 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1793 } else if (ret < 0)
1794 exit_program(1);
1795 }
1796 }
1797 else {
1798 switch (type) {
1799 case 'g':
1800 m = &oc->metadata;
1801 break;
1802 case 'c':
1803 if (index < 0 || index >= oc->nb_chapters) {
1804 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1805 exit_program(1);
1806 }
1807 m = &oc->chapters[index]->metadata;
1808 break;
1809 default:
1810 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1811 exit_program(1);
1812 }
1813 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1814 }
1815 }
1816
1817 return 0;
1818 }
1819
1820 static int opt_target(void *optctx, const char *opt, const char *arg)
1821 {
1822 OptionsContext *o = optctx;
1823 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1824 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1825
1826 if (!strncmp(arg, "pal-", 4)) {
1827 norm = PAL;
1828 arg += 4;
1829 } else if (!strncmp(arg, "ntsc-", 5)) {
1830 norm = NTSC;
1831 arg += 5;
1832 } else if (!strncmp(arg, "film-", 5)) {
1833 norm = FILM;
1834 arg += 5;
1835 } else {
1836 /* Try to determine PAL/NTSC by peeking in the input files */
1837 if (nb_input_files) {
1838 int i, j, fr;
1839 for (j = 0; j < nb_input_files; j++) {
1840 for (i = 0; i < input_files[j]->nb_streams; i++) {
1841 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1842 if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
1843 !c->time_base.num)
1844 continue;
1845 fr = c->time_base.den * 1000 / c->time_base.num;
1846 if (fr == 25000) {
1847 norm = PAL;
1848 break;
1849 } else if ((fr == 29970) || (fr == 23976)) {
1850 norm = NTSC;
1851 break;
1852 }
1853 }
1854 if (norm != UNKNOWN)
1855 break;
1856 }
1857 }
1858 if (norm != UNKNOWN)
1859 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1860 }
1861
1862 if (norm == UNKNOWN) {
1863 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1864 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1865 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1866 exit_program(1);
1867 }
1868
1869 if (!strcmp(arg, "vcd")) {
1870 opt_video_codec(o, "c:v", "mpeg1video");
1871 opt_audio_codec(o, "c:a", "mp2");
1872 parse_option(o, "f", "vcd", options);
1873
1874 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1875 parse_option(o, "r", frame_rates[norm], options);
1876 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1877
1878 opt_default(NULL, "b", "1150000");
1879 opt_default(NULL, "maxrate", "1150000");
1880 opt_default(NULL, "minrate", "1150000");
1881 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1882
1883 opt_default(NULL, "b:a", "224000");
1884 parse_option(o, "ar", "44100", options);
1885 parse_option(o, "ac", "2", options);
1886
1887 opt_default(NULL, "packetsize", "2324");
1888 opt_default(NULL, "muxrate", "3528"); // 2352 * 75 / 50;
1889
1890 /* We have to offset the PTS, so that it is consistent with the SCR.
1891 SCR starts at 36000, but the first two packs contain only padding
1892 and the first pack from the other stream, respectively, may also have
1893 been written before.
1894 So the real data starts at SCR 36000+3*1200. */
1895 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1896 } else if (!strcmp(arg, "svcd")) {
1897
1898 opt_video_codec(o, "c:v", "mpeg2video");
1899 opt_audio_codec(o, "c:a", "mp2");
1900 parse_option(o, "f", "svcd", options);
1901
1902 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1903 parse_option(o, "r", frame_rates[norm], options);
1904 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1905
1906 opt_default(NULL, "b", "2040000");
1907 opt_default(NULL, "maxrate", "2516000");
1908 opt_default(NULL, "minrate", "0"); // 1145000;
1909 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1910 opt_default(NULL, "scan_offset", "1");
1911
1912
1913 opt_default(NULL, "b:a", "224000");
1914 parse_option(o, "ar", "44100", options);
1915
1916 opt_default(NULL, "packetsize", "2324");
1917
1918 } else if (!strcmp(arg, "dvd")) {
1919
1920 opt_video_codec(o, "c:v", "mpeg2video");
1921 opt_audio_codec(o, "c:a", "ac3");
1922 parse_option(o, "f", "dvd", options);
1923
1924 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1925 parse_option(o, "r", frame_rates[norm], options);
1926 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1927
1928 opt_default(NULL, "b", "6000000");
1929 opt_default(NULL, "maxrate", "9000000");
1930 opt_default(NULL, "minrate", "0"); // 1500000;
1931 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1932
1933 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1934 opt_default(NULL, "muxrate", "25200"); // from mplex project: data_rate = 1260000. mux_rate = data_rate / 50
1935
1936 opt_default(NULL, "b:a", "448000");
1937 parse_option(o, "ar", "48000", options);
1938
1939 } else if (!strncmp(arg, "dv", 2)) {
1940
1941 parse_option(o, "f", "dv", options);
1942
1943 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1944 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1945 norm == PAL ? "yuv420p" : "yuv411p", options);
1946 parse_option(o, "r", frame_rates[norm], options);
1947
1948 parse_option(o, "ar", "48000", options);
1949 parse_option(o, "ac", "2", options);
1950
1951 } else {
1952 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1953 return AVERROR(EINVAL);
1954 }
1955
1956 av_dict_copy(&o->g->codec_opts, codec_opts, 0);
1957 av_dict_copy(&o->g->format_opts, format_opts, 0);
1958
1959 return 0;
1960 }
1961
1962 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1963 {
1964 av_free (vstats_filename);
1965 vstats_filename = av_strdup (arg);
1966 return 0;
1967 }
1968
1969 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1970 {
1971 char filename[40];
1972 time_t today2 = time(NULL);
1973 struct tm *today = localtime(&today2);
1974
1975 if (!today) { // maybe tomorrow
1976 av_log(NULL, AV_LOG_FATAL, "Unable to get current time.\n");
1977 exit_program(1);
1978 }
1979
1980 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1981 today->tm_sec);
1982 return opt_vstats_file(NULL, opt, filename);
1983 }
1984
1985 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1986 {
1987 OptionsContext *o = optctx;
1988 return parse_option(o, "frames:v", arg, options);
1989 }
1990
1991 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1992 {
1993 OptionsContext *o = optctx;
1994 return parse_option(o, "frames:a", arg, options);
1995 }
1996
1997 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1998 {
1999 OptionsContext *o = optctx;
2000 return parse_option(o, "frames:d", arg, options);
2001 }
2002
2003 static int opt_video_tag(void *optctx, const char *opt, const char *arg)
2004 {
2005 OptionsContext *o = optctx;
2006 return parse_option(o, "tag:v", arg, options);
2007 }
2008
2009 static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
2010 {
2011 OptionsContext *o = optctx;
2012 return parse_option(o, "tag:a", arg, options);
2013 }
2014
2015 static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
2016 {
2017 OptionsContext *o = optctx;
2018 return parse_option(o, "tag:s", arg, options);
2019 }
2020
2021 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2022 {
2023 OptionsContext *o = optctx;
2024 return parse_option(o, "filter:v", arg, options);
2025 }
2026
2027 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2028 {
2029 OptionsContext *o = optctx;
2030 return parse_option(o, "filter:a", arg, options);
2031 }
2032
2033 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2034 {
2035 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2036 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2037 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2038
2039 if (video_sync_method == VSYNC_AUTO)
2040 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2041 return 0;
2042 }
2043
2044 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2045 {
2046 OptionsContext *o = optctx;
2047 char layout_str[32];
2048 char *stream_str;
2049 char *ac_str;
2050 int ret, channels, ac_str_size;
2051 uint64_t layout;
2052
2053 layout = av_get_channel_layout(arg);
2054 if (!layout) {
2055 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2056 return AVERROR(EINVAL);
2057 }
2058 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2059 ret = opt_default(NULL, opt, layout_str);
2060 if (ret < 0)
2061 return ret;
2062
2063 /* set 'ac' option based on channel layout */
2064 channels = av_get_channel_layout_nb_channels(layout);
2065 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2066 stream_str = strchr(opt, ':');
2067 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2068 ac_str = av_mallocz(ac_str_size);
2069 if (!ac_str)
2070 return AVERROR(ENOMEM);
2071 av_strlcpy(ac_str, "ac", 3);
2072 if (stream_str)
2073 av_strlcat(ac_str, stream_str, ac_str_size);
2074 ret = parse_option(o, ac_str, layout_str, options);
2075 av_free(ac_str);
2076
2077 return ret;
2078 }
2079
2080 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2081 {
2082 OptionsContext *o = optctx;
2083 return parse_option(o, "q:a", arg, options);
2084 }
2085
2086 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2087 {
2088 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2089 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2090 return AVERROR(ENOMEM);
2091 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2092 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2093 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2094 return AVERROR(ENOMEM);
2095 return 0;
2096 }
2097
2098 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2099 {
2100 uint8_t *graph_desc = read_file(arg);
2101 if (!graph_desc)
2102 return AVERROR(EINVAL);
2103
2104 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2105 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2106 return AVERROR(ENOMEM);
2107 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2108 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2109 return 0;
2110 }
2111
2112 void show_help_default(const char *opt, const char *arg)
2113 {
2114 /* per-file options have at least one of those set */
2115 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2116 int show_advanced = 0, show_avoptions = 0;
2117
2118 if (opt && *opt) {
2119 if (!strcmp(opt, "long"))
2120 show_advanced = 1;
2121 else if (!strcmp(opt, "full"))
2122 show_advanced = show_avoptions = 1;
2123 else
2124 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2125 }
2126
2127 show_usage();
2128
2129 printf("Getting help:\n"
2130 " -h -- print basic options\n"
2131 " -h long -- print more options\n"
2132 " -h full -- print all options (including all format and codec specific options, very long)\n"
2133 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
2134 " See man %s for detailed description of the options.\n"
2135 "\n", program_name);
2136
2137 show_help_options(options, "Print help / information / capabilities:",
2138 OPT_EXIT, 0, 0);
2139
2140 show_help_options(options, "Global options (affect whole program "
2141 "instead of just one file:",
2142 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2143 if (show_advanced)
2144 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2145 per_file | OPT_EXIT, 0);
2146
2147 show_help_options(options, "Per-file main options:", 0,
2148 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2149 OPT_EXIT, per_file);
2150 if (show_advanced)
2151 show_help_options(options, "Advanced per-file options:",
2152 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2153
2154 show_help_options(options, "Video options:",
2155 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2156 if (show_advanced)
2157 show_help_options(options, "Advanced Video options:",
2158 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2159
2160 show_help_options(options, "Audio options:",
2161 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2162 if (show_advanced)
2163 show_help_options(options, "Advanced Audio options:",
2164 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2165 show_help_options(options, "Subtitle options:",
2166 OPT_SUBTITLE, 0, 0);
2167 printf("\n");
2168
2169 if (show_avoptions) {
2170 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2171 show_help_children(avcodec_get_class(), flags);
2172 show_help_children(avformat_get_class(), flags);
2173 show_help_children(sws_get_class(), flags);
2174 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM);
2175 }
2176 }
2177
2178 void show_usage(void)
2179 {
2180 printf("Hyper fast Audio and Video encoder\n");
2181 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2182 printf("\n");
2183 }
2184
2185 enum OptGroup {
2186 GROUP_OUTFILE,
2187 GROUP_INFILE,
2188 };
2189
2190 static const OptionGroupDef groups[] = {
2191 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2192 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2193 };
2194
2195 static int open_files(OptionGroupList *l, const char *inout,
2196 int (*open_file)(OptionsContext*, const char*))
2197 {
2198 int i, ret;
2199
2200 for (i = 0; i < l->nb_groups; i++) {
2201 OptionGroup *g = &l->groups[i];
2202 OptionsContext o;
2203
2204 init_options(&o);
2205 o.g = g;
2206
2207 ret = parse_optgroup(&o, g);
2208 if (ret < 0) {
2209 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2210 "%s.\n", inout, g->arg);
2211 return ret;
2212 }
2213
2214 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2215 ret = open_file(&o, g->arg);
2216 uninit_options(&o);
2217 if (ret < 0) {
2218 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2219 inout, g->arg);
2220 return ret;
2221 }
2222 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2223 }
2224
2225 return 0;
2226 }
2227
2228 int avconv_parse_options(int argc, char **argv)
2229 {
2230 OptionParseContext octx;
2231 uint8_t error[128];
2232 int ret;
2233
2234 memset(&octx, 0, sizeof(octx));
2235
2236 /* split the commandline into an internal representation */
2237 ret = split_commandline(&octx, argc, argv, options, groups,
2238 FF_ARRAY_ELEMS(groups));
2239 if (ret < 0) {
2240 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2241 goto fail;
2242 }
2243
2244 /* apply global options */
2245 ret = parse_optgroup(NULL, &octx.global_opts);
2246 if (ret < 0) {
2247 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2248 goto fail;
2249 }
2250
2251 /* open input files */
2252 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2253 if (ret < 0) {
2254 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2255 goto fail;
2256 }
2257
2258 /* create the complex filtergraphs */
2259 ret = init_complex_filters();
2260 if (ret < 0) {
2261 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
2262 goto fail;
2263 }
2264
2265 /* open output files */
2266 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2267 if (ret < 0) {
2268 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2269 goto fail;
2270 }
2271
2272 /* configure the complex filtergraphs */
2273 ret = configure_complex_filters();
2274 if (ret < 0) {
2275 av_log(NULL, AV_LOG_FATAL, "Error configuring complex filters.\n");
2276 goto fail;
2277 }
2278
2279 fail:
2280 uninit_parse_context(&octx);
2281 if (ret < 0) {
2282 av_strerror(ret, error, sizeof(error));
2283 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2284 }
2285 return ret;
2286 }
2287
2288 #define OFFSET(x) offsetof(OptionsContext, x)
2289 const OptionDef options[] = {
2290 /* main options */
2291 #include "cmdutils_common_opts.h"
2292 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2293 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2294 "force format", "fmt" },
2295 { "y", OPT_BOOL, { &file_overwrite },
2296 "overwrite output files" },
2297 { "n", OPT_BOOL, { &file_skip },
2298 "never overwrite output files" },
2299 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2300 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2301 "codec name", "codec" },
2302 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2303 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2304 "codec name", "codec" },
2305 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2306 OPT_OUTPUT, { .off = OFFSET(presets) },
2307 "preset name", "preset" },
2308 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2309 OPT_OUTPUT, { .func_arg = opt_map },
2310 "set input stream mapping",
2311 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2312 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2313 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2314 "set metadata information of outfile from infile",
2315 "outfile[,metadata]:infile[,metadata]" },
2316 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2317 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2318 "set chapters mapping", "input_file_index" },
2319 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2320 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2321 "record or transcode \"duration\" seconds of audio/video",
2322 "duration" },
2323 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2324 "set the limit file size in bytes", "limit_size" },
2325 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2326 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2327 "set the start time offset", "time_off" },
2328 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2329 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2330 "enable/disable accurate seeking with -ss" },
2331 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2332 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2333 "set the input ts offset", "time_off" },
2334 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2335 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2336 "set the input ts scale", "scale" },
2337 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2338 "add metadata", "string=string" },
2339 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2340 OPT_OUTPUT, { .func_arg = opt_data_frames },
2341 "set the number of data frames to record", "number" },
2342 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2343 "add timings for benchmarking" },
2344 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2345 "set max runtime in seconds", "limit" },
2346 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2347 "dump each input packet" },
2348 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2349 "when dumping packets, also dump the payload" },
2350 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2351 OPT_INPUT, { .off = OFFSET(rate_emu) },
2352 "read input at native frame rate", "" },
2353 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2354 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2355 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2356 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2357 "video sync method", "" },
2358 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2359 "audio sync method", "" },
2360 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2361 "audio drift threshold", "threshold" },
2362 { "copyts", OPT_BOOL | OPT_EXPERT, { &copy_ts },
2363 "copy timestamps" },
2364 { "copytb", OPT_BOOL | OPT_EXPERT, { &copy_tb },
2365 "copy input stream time base when stream copying" },
2366 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2367 OPT_OUTPUT, { .off = OFFSET(shortest) },
2368 "finish encoding within shortest input" },
2369 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2370 "timestamp discontinuity delta threshold", "threshold" },
2371 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2372 "exit on error", "error" },
2373 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2374 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2375 "copy initial non-keyframes" },
2376 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2377 "set the number of frames to record", "number" },
2378 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2379 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
2380 "force codec tag/fourcc", "fourcc/tag" },
2381 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2382 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2383 "use fixed quality scale (VBR)", "q" },
2384 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2385 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2386 "use fixed quality scale (VBR)", "q" },
2387 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2388 "set stream filterchain", "filter_list" },
2389 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2390 "read stream filtergraph description from a file", "filename" },
2391 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2392 "create a complex filtergraph", "graph_description" },
2393 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2394 "read complex filtergraph description from a file", "filename" },
2395 { "stats", OPT_BOOL, { &print_stats },
2396 "print progress report during encoding", },
2397 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2398 OPT_OUTPUT, { .func_arg = opt_attach },
2399 "add an attachment to the output file", "filename" },
2400 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2401 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2402 "extract an attachment into a file", "filename" },
2403 { "loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
2404 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
2405
2406 /* video options */
2407 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2408 "set the number of video frames to record", "number" },
2409 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2410 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2411 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2412 { "s", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2413 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2414 "set frame size (WxH or abbreviation)", "size" },
2415 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2416 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2417 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2418 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2419 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2420 "set pixel format", "format" },
2421 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(video_disable) },
2422 "disable video" },
2423 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2424 "discard threshold", "n" },
2425 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2426 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2427 "rate control override for specific intervals", "override" },
2428 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2429 OPT_OUTPUT, { .func_arg = opt_video_codec },
2430 "force video codec ('copy' to copy stream)", "codec" },
2431 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2432 "select the pass number (1 or 2)", "n" },
2433 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2434 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2435 "select two pass log file name prefix", "prefix" },
2436 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2437 "dump video coding statistics to file" },
2438 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2439 "dump video coding statistics to file", "file" },
2440 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2441 "video filters", "filter list" },
2442 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2443 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2444 "specify intra matrix coeffs", "matrix" },
2445 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2446 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2447 "specify inter matrix coeffs", "matrix" },
2448 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2449 OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2450 "top=1/bottom=0/auto=-1 field first", "" },
2451 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2452 "intra_dc_precision", "precision" },
2453 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2454 OPT_OUTPUT, { .func_arg = opt_video_tag },
2455 "force video tag/fourcc", "fourcc/tag" },
2456 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2457 "show QP histogram" },
2458 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2459 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2460 "force the selected framerate, disable the best supported framerate selection" },
2461 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2462 OPT_OUTPUT, { .func_arg = opt_streamid },
2463 "set the value of an outfile streamid", "streamIndex:value" },
2464 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2465 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2466 "force key frames at specified timestamps", "timestamps" },
2467 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2468 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
2469 "use HW accelerated decoding", "hwaccel name" },
2470 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2471 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
2472 "select a device for HW acceleration", "devicename" },
2473 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
2474 "show available HW acceleration methods" },
2475 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
2476 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
2477 "automatically insert correct rotate filters" },
2478
2479 /* audio options */
2480 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2481 "set the number of audio frames to record", "number" },
2482 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2483 "set audio quality (codec-specific)", "quality", },
2484 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2485 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2486 "set audio sampling rate (in Hz)", "rate" },
2487 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2488 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2489 "set number of audio channels", "channels" },
2490 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(audio_disable) },
2491 "disable audio" },
2492 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2493 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2494 "force audio codec ('copy' to copy stream)", "codec" },
2495 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2496 OPT_OUTPUT, { .func_arg = opt_audio_tag },
2497 "force audio tag/fourcc", "fourcc/tag" },
2498 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2499 "change audio volume (256=normal)" , "volume" },
2500 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2501 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
2502 "set sample format", "format" },
2503 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2504 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2505 "set channel layout", "layout" },
2506 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2507 "audio filters", "filter list" },
2508
2509 /* subtitle options */
2510 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2511 "disable subtitle" },
2512 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2513 "force subtitle codec ('copy' to copy stream)", "codec" },
2514 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_subtitle_tag }
2515 , "force subtitle tag/fourcc", "fourcc/tag" },
2516
2517 /* grab options */
2518 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2519
2520 /* muxer options */
2521 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2522 "set the maximum demux-decode delay", "seconds" },
2523 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2524 "set the initial demux-decode delay", "seconds" },
2525
2526 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2527 "A comma-separated list of bitstream filters", "bitstream_filters" },
2528
2529 /* data codec support */
2530 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2531 "force data codec ('copy' to copy stream)", "codec" },
2532
2533 { NULL, },
2534 };