FFmpeg  2.6.9
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
ffmpeg_opt.c
Go to the documentation of this file.
1 /*
2  * ffmpeg option parsing
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include <stdint.h>
22 
23 #include "ffmpeg.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"
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 MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
45 {\
46  int i, ret;\
47  for (i = 0; i < o->nb_ ## name; i++) {\
48  char *spec = o->name[i].specifier;\
49  if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
50  outvar = o->name[i].u.type;\
51  else if (ret < 0)\
52  exit_program(1);\
53  }\
54 }
55 
56 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
57 {\
58  int i;\
59  for (i = 0; i < o->nb_ ## name; i++) {\
60  char *spec = o->name[i].specifier;\
61  if (!strcmp(spec, mediatype))\
62  outvar = o->name[i].u.type;\
63  }\
64 }
65 
66 const HWAccel hwaccels[] = {
67 #if HAVE_VDPAU_X11
69 #endif
70 #if HAVE_DXVA2_LIB
72 #endif
73 #if CONFIG_VDA
74  { "vda", vda_init, HWACCEL_VDA, AV_PIX_FMT_VDA },
75 #endif
76  { 0 },
77 };
78 
81 
84 float dts_error_threshold = 3600*30;
85 
86 int audio_volume = 256;
91 int do_benchmark = 0;
93 int do_hex_dump = 0;
94 int do_pkt_dump = 0;
95 int copy_ts = 0;
96 int start_at_zero = 0;
97 int copy_tb = -1;
98 int debug_ts = 0;
99 int exit_on_error = 0;
100 int print_stats = -1;
101 int qp_hist = 0;
104 float max_error_rate = 2.0/3;
105 
106 
107 static int intra_only = 0;
108 static int file_overwrite = 0;
109 static int no_file_overwrite = 0;
110 static int do_psnr = 0;
111 static int input_sync;
112 static int override_ffserver = 0;
113 
115 {
116  const OptionDef *po = options;
117  int i;
118 
119  /* all OPT_SPEC and OPT_STRING can be freed in generic way */
120  while (po->name) {
121  void *dst = (uint8_t*)o + po->u.off;
122 
123  if (po->flags & OPT_SPEC) {
124  SpecifierOpt **so = dst;
125  int i, *count = (int*)(so + 1);
126  for (i = 0; i < *count; i++) {
127  av_freep(&(*so)[i].specifier);
128  if (po->flags & OPT_STRING)
129  av_freep(&(*so)[i].u.str);
130  }
131  av_freep(so);
132  *count = 0;
133  } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
134  av_freep(dst);
135  po++;
136  }
137 
138  for (i = 0; i < o->nb_stream_maps; i++)
140  av_freep(&o->stream_maps);
142  av_freep(&o->streamid_map);
143  av_freep(&o->attachments);
144 }
145 
147 {
148  memset(o, 0, sizeof(*o));
149 
150  o->stop_time = INT64_MAX;
151  o->mux_max_delay = 0.7;
153  o->recording_time = INT64_MAX;
154  o->limit_filesize = UINT64_MAX;
155  o->chapters_input_file = INT_MAX;
156  o->accurate_seek = 1;
157 }
158 
159 /* return a copy of the input with the stream specifiers removed from the keys */
161 {
162  AVDictionaryEntry *e = NULL;
163  AVDictionary *ret = NULL;
164 
165  while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
166  char *p = strchr(e->key, ':');
167 
168  if (p)
169  *p = 0;
170  av_dict_set(&ret, e->key, e->value, 0);
171  if (p)
172  *p = ':';
173  }
174  return ret;
175 }
176 
177 static int opt_sameq(void *optctx, const char *opt, const char *arg)
178 {
179  av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
180  "If you are looking for an option to preserve the quality (which is not "
181  "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
182  opt, opt);
183  return AVERROR(EINVAL);
184 }
185 
186 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
187 {
188  av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
189  return opt_default(optctx, "channel", arg);
190 }
191 
192 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
193 {
194  av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
195  return opt_default(optctx, "standard", arg);
196 }
197 
198 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
199 {
200  OptionsContext *o = optctx;
201  return parse_option(o, "codec:a", arg, options);
202 }
203 
204 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
205 {
206  OptionsContext *o = optctx;
207  return parse_option(o, "codec:v", arg, options);
208 }
209 
210 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
211 {
212  OptionsContext *o = optctx;
213  return parse_option(o, "codec:s", arg, options);
214 }
215 
216 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
217 {
218  OptionsContext *o = optctx;
219  return parse_option(o, "codec:d", arg, options);
220 }
221 
222 static int opt_map(void *optctx, const char *opt, const char *arg)
223 {
224  OptionsContext *o = optctx;
225  StreamMap *m = NULL;
226  int i, negative = 0, file_idx;
227  int sync_file_idx = -1, sync_stream_idx = 0;
228  char *p, *sync;
229  char *map;
230 
231  if (*arg == '-') {
232  negative = 1;
233  arg++;
234  }
235  map = av_strdup(arg);
236  if (!map)
237  return AVERROR(ENOMEM);
238 
239  /* parse sync stream first, just pick first matching stream */
240  if (sync = strchr(map, ',')) {
241  *sync = 0;
242  sync_file_idx = strtol(sync + 1, &sync, 0);
243  if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
244  av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
245  exit_program(1);
246  }
247  if (*sync)
248  sync++;
249  for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
250  if (check_stream_specifier(input_files[sync_file_idx]->ctx,
251  input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
252  sync_stream_idx = i;
253  break;
254  }
255  if (i == input_files[sync_file_idx]->nb_streams) {
256  av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
257  "match any streams.\n", arg);
258  exit_program(1);
259  }
260  }
261 
262 
263  if (map[0] == '[') {
264  /* this mapping refers to lavfi output */
265  const char *c = map + 1;
267  m = &o->stream_maps[o->nb_stream_maps - 1];
268  m->linklabel = av_get_token(&c, "]");
269  if (!m->linklabel) {
270  av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
271  exit_program(1);
272  }
273  } else {
274  file_idx = strtol(map, &p, 0);
275  if (file_idx >= nb_input_files || file_idx < 0) {
276  av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
277  exit_program(1);
278  }
279  if (negative)
280  /* disable some already defined maps */
281  for (i = 0; i < o->nb_stream_maps; i++) {
282  m = &o->stream_maps[i];
283  if (file_idx == m->file_index &&
286  *p == ':' ? p + 1 : p) > 0)
287  m->disabled = 1;
288  }
289  else
290  for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
291  if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
292  *p == ':' ? p + 1 : p) <= 0)
293  continue;
295  m = &o->stream_maps[o->nb_stream_maps - 1];
296 
297  m->file_index = file_idx;
298  m->stream_index = i;
299 
300  if (sync_file_idx >= 0) {
301  m->sync_file_index = sync_file_idx;
302  m->sync_stream_index = sync_stream_idx;
303  } else {
304  m->sync_file_index = file_idx;
305  m->sync_stream_index = i;
306  }
307  }
308  }
309 
310  if (!m) {
311  av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
312  exit_program(1);
313  }
314 
315  av_freep(&map);
316  return 0;
317 }
318 
319 static int opt_attach(void *optctx, const char *opt, const char *arg)
320 {
321  OptionsContext *o = optctx;
323  o->attachments[o->nb_attachments - 1] = arg;
324  return 0;
325 }
326 
327 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
328 {
329  OptionsContext *o = optctx;
330  int n;
331  AVStream *st;
333 
336 
337  /* muted channel syntax */
338  n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
339  if ((n == 1 || n == 3) && m->channel_idx == -1) {
340  m->file_idx = m->stream_idx = -1;
341  if (n == 1)
342  m->ofile_idx = m->ostream_idx = -1;
343  return 0;
344  }
345 
346  /* normal syntax */
347  n = sscanf(arg, "%d.%d.%d:%d.%d",
348  &m->file_idx, &m->stream_idx, &m->channel_idx,
349  &m->ofile_idx, &m->ostream_idx);
350 
351  if (n != 3 && n != 5) {
352  av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
353  "[file.stream.channel|-1][:syncfile:syncstream]\n");
354  exit_program(1);
355  }
356 
357  if (n != 5) // only file.stream.channel specified
358  m->ofile_idx = m->ostream_idx = -1;
359 
360  /* check input */
361  if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
362  av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
363  m->file_idx);
364  exit_program(1);
365  }
366  if (m->stream_idx < 0 ||
368  av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
369  m->file_idx, m->stream_idx);
370  exit_program(1);
371  }
372  st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
373  if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
374  av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
375  m->file_idx, m->stream_idx);
376  exit_program(1);
377  }
378  if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
379  av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
380  m->file_idx, m->stream_idx, m->channel_idx);
381  exit_program(1);
382  }
383  return 0;
384 }
385 
386 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
387 {
389  sdp_filename = av_strdup(arg);
390  return 0;
391 }
392 
393 /**
394  * Parse a metadata specifier passed as 'arg' parameter.
395  * @param arg metadata string to parse
396  * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
397  * @param index for type c/p, chapter/program index is written here
398  * @param stream_spec for type s, the stream specifier is written here
399  */
400 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
401 {
402  if (*arg) {
403  *type = *arg;
404  switch (*arg) {
405  case 'g':
406  break;
407  case 's':
408  if (*(++arg) && *arg != ':') {
409  av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
410  exit_program(1);
411  }
412  *stream_spec = *arg == ':' ? arg + 1 : "";
413  break;
414  case 'c':
415  case 'p':
416  if (*(++arg) == ':')
417  *index = strtol(++arg, NULL, 0);
418  break;
419  default:
420  av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
421  exit_program(1);
422  }
423  } else
424  *type = 'g';
425 }
426 
427 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
428 {
429  AVDictionary **meta_in = NULL;
430  AVDictionary **meta_out = NULL;
431  int i, ret = 0;
432  char type_in, type_out;
433  const char *istream_spec = NULL, *ostream_spec = NULL;
434  int idx_in = 0, idx_out = 0;
435 
436  parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
437  parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
438 
439  if (!ic) {
440  if (type_out == 'g' || !*outspec)
441  o->metadata_global_manual = 1;
442  if (type_out == 's' || !*outspec)
444  if (type_out == 'c' || !*outspec)
446  return 0;
447  }
448 
449  if (type_in == 'g' || type_out == 'g')
450  o->metadata_global_manual = 1;
451  if (type_in == 's' || type_out == 's')
453  if (type_in == 'c' || type_out == 'c')
455 
456  /* ic is NULL when just disabling automatic mappings */
457  if (!ic)
458  return 0;
459 
460 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
461  if ((index) < 0 || (index) >= (nb_elems)) {\
462  av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
463  (desc), (index));\
464  exit_program(1);\
465  }
466 
467 #define SET_DICT(type, meta, context, index)\
468  switch (type) {\
469  case 'g':\
470  meta = &context->metadata;\
471  break;\
472  case 'c':\
473  METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
474  meta = &context->chapters[index]->metadata;\
475  break;\
476  case 'p':\
477  METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
478  meta = &context->programs[index]->metadata;\
479  break;\
480  case 's':\
481  break; /* handled separately below */ \
482  default: av_assert0(0);\
483  }\
484 
485  SET_DICT(type_in, meta_in, ic, idx_in);
486  SET_DICT(type_out, meta_out, oc, idx_out);
487 
488  /* for input streams choose first matching stream */
489  if (type_in == 's') {
490  for (i = 0; i < ic->nb_streams; i++) {
491  if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
492  meta_in = &ic->streams[i]->metadata;
493  break;
494  } else if (ret < 0)
495  exit_program(1);
496  }
497  if (!meta_in) {
498  av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
499  exit_program(1);
500  }
501  }
502 
503  if (type_out == 's') {
504  for (i = 0; i < oc->nb_streams; i++) {
505  if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
506  meta_out = &oc->streams[i]->metadata;
507  av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
508  } else if (ret < 0)
509  exit_program(1);
510  }
511  } else
512  av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
513 
514  return 0;
515 }
516 
517 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
518 {
519  OptionsContext *o = optctx;
520  char buf[128];
521  int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
522  struct tm time = *gmtime((time_t*)&recording_timestamp);
523  if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
524  return -1;
525  parse_option(o, "metadata", buf, options);
526 
527  av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
528  "tag instead.\n", opt);
529  return 0;
530 }
531 
532 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
533 {
534  const AVCodecDescriptor *desc;
535  const char *codec_string = encoder ? "encoder" : "decoder";
536  AVCodec *codec;
537 
538  codec = encoder ?
541 
542  if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
543  codec = encoder ? avcodec_find_encoder(desc->id) :
544  avcodec_find_decoder(desc->id);
545  if (codec)
546  av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
547  codec_string, codec->name, desc->name);
548  }
549 
550  if (!codec) {
551  av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
552  exit_program(1);
553  }
554  if (codec->type != type) {
555  av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
556  exit_program(1);
557  }
558  return codec;
559 }
560 
562 {
563  char *codec_name = NULL;
564 
565  MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
566  if (codec_name) {
567  AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
568  st->codec->codec_id = codec->id;
569  return codec;
570  } else
571  return avcodec_find_decoder(st->codec->codec_id);
572 }
573 
574 /* Add all the streams from the given input file to the global
575  * list of input streams. */
577 {
578  int i, ret;
579 
580  for (i = 0; i < ic->nb_streams; i++) {
581  AVStream *st = ic->streams[i];
582  AVCodecContext *dec = st->codec;
583  InputStream *ist = av_mallocz(sizeof(*ist));
584  char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
585  char *codec_tag = NULL;
586  char *next;
587  char *discard_str = NULL;
588  const AVOption *discard_opt = av_opt_find(dec, "skip_frame", NULL, 0, 0);
589 
590  if (!ist)
591  exit_program(1);
592 
594  input_streams[nb_input_streams - 1] = ist;
595 
596  ist->st = st;
597  ist->file_index = nb_input_files;
598  ist->discard = 1;
599  st->discard = AVDISCARD_ALL;
600 
601  ist->ts_scale = 1.0;
602  MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
603 
604  MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
605  if (codec_tag) {
606  uint32_t tag = strtol(codec_tag, &next, 0);
607  if (*next)
608  tag = AV_RL32(codec_tag);
609  st->codec->codec_tag = tag;
610  }
611 
612  ist->dec = choose_decoder(o, ic, st);
613  ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
614 
615  ist->reinit_filters = -1;
616  MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
617 
618  MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
620  if (discard_str && av_opt_eval_int(dec, discard_opt, discard_str, &ist->user_set_discard) < 0) {
621  av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
622  discard_str);
623  exit_program(1);
624  }
625 
627 
628  ist->dec_ctx = avcodec_alloc_context3(ist->dec);
629  if (!ist->dec_ctx) {
630  av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
631  exit_program(1);
632  }
633 
634  ret = avcodec_copy_context(ist->dec_ctx, dec);
635  if (ret < 0) {
636  av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
637  exit_program(1);
638  }
639 
640  switch (dec->codec_type) {
641  case AVMEDIA_TYPE_VIDEO:
642  if(!ist->dec)
643  ist->dec = avcodec_find_decoder(dec->codec_id);
644  if (av_codec_get_lowres(dec)) {
645  dec->flags |= CODEC_FLAG_EMU_EDGE;
646  }
647 
648  ist->resample_height = ist->dec_ctx->height;
649  ist->resample_width = ist->dec_ctx->width;
650  ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
651 
652  MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
653  if (framerate && av_parse_video_rate(&ist->framerate,
654  framerate) < 0) {
655  av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
656  framerate);
657  exit_program(1);
658  }
659 
660  ist->top_field_first = -1;
661  MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
662 
663  MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
664  if (hwaccel) {
665  if (!strcmp(hwaccel, "none"))
666  ist->hwaccel_id = HWACCEL_NONE;
667  else if (!strcmp(hwaccel, "auto"))
668  ist->hwaccel_id = HWACCEL_AUTO;
669  else {
670  int i;
671  for (i = 0; hwaccels[i].name; i++) {
672  if (!strcmp(hwaccels[i].name, hwaccel)) {
673  ist->hwaccel_id = hwaccels[i].id;
674  break;
675  }
676  }
677 
678  if (!ist->hwaccel_id) {
679  av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
680  hwaccel);
681  av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
682  for (i = 0; hwaccels[i].name; i++)
683  av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
684  av_log(NULL, AV_LOG_FATAL, "\n");
685  exit_program(1);
686  }
687  }
688  }
689 
690  MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
691  if (hwaccel_device) {
692  ist->hwaccel_device = av_strdup(hwaccel_device);
693  if (!ist->hwaccel_device)
694  exit_program(1);
695  }
697 
698  break;
699  case AVMEDIA_TYPE_AUDIO:
700  ist->guess_layout_max = INT_MAX;
701  MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
703 
706  ist->resample_channels = ist->dec_ctx->channels;
708 
709  break;
710  case AVMEDIA_TYPE_DATA:
711  case AVMEDIA_TYPE_SUBTITLE: {
712  char *canvas_size = NULL;
713  if(!ist->dec)
714  ist->dec = avcodec_find_decoder(dec->codec_id);
715  MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
716  MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
717  if (canvas_size &&
718  av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
719  av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
720  exit_program(1);
721  }
722  break;
723  }
726  break;
727  default:
728  abort();
729  }
730  }
731 }
732 
733 static void assert_file_overwrite(const char *filename)
734 {
736  fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
737  exit_program(1);
738  }
739 
740  if (!file_overwrite) {
741  const char *proto_name = avio_find_protocol_name(filename);
742  if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
744  fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
745  fflush(stderr);
746  term_exit();
747  signal(SIGINT, SIG_DFL);
748  if (!read_yesno()) {
749  av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
750  exit_program(1);
751  }
752  term_init();
753  }
754  else {
755  av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
756  exit_program(1);
757  }
758  }
759  }
760 }
761 
762 static void dump_attachment(AVStream *st, const char *filename)
763 {
764  int ret;
765  AVIOContext *out = NULL;
767 
768  if (!st->codec->extradata_size) {
769  av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
770  nb_input_files - 1, st->index);
771  return;
772  }
773  if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
774  filename = e->value;
775  if (!*filename) {
776  av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
777  "in stream #%d:%d.\n", nb_input_files - 1, st->index);
778  exit_program(1);
779  }
780 
781  assert_file_overwrite(filename);
782 
783  if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
784  av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
785  filename);
786  exit_program(1);
787  }
788 
789  avio_write(out, st->codec->extradata, st->codec->extradata_size);
790  avio_flush(out);
791  avio_close(out);
792 }
793 
794 static int open_input_file(OptionsContext *o, const char *filename)
795 {
796  InputFile *f;
797  AVFormatContext *ic;
799  int err, i, ret;
800  int64_t timestamp;
801  AVDictionary **opts;
802  AVDictionary *unused_opts = NULL;
803  AVDictionaryEntry *e = NULL;
804  int orig_nb_streams; // number of streams before avformat_find_stream_info
805  char * video_codec_name = NULL;
806  char * audio_codec_name = NULL;
807  char *subtitle_codec_name = NULL;
808  char * data_codec_name = NULL;
809  int scan_all_pmts_set = 0;
810 
811  if (o->format) {
812  if (!(file_iformat = av_find_input_format(o->format))) {
813  av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
814  exit_program(1);
815  }
816  }
817 
818  if (!strcmp(filename, "-"))
819  filename = "pipe:";
820 
821  stdin_interaction &= strncmp(filename, "pipe:", 5) &&
822  strcmp(filename, "/dev/stdin");
823 
824  /* get default parameters from command line */
825  ic = avformat_alloc_context();
826  if (!ic) {
827  print_error(filename, AVERROR(ENOMEM));
828  exit_program(1);
829  }
830  if (o->nb_audio_sample_rate) {
831  av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
832  }
833  if (o->nb_audio_channels) {
834  /* because we set audio_channels based on both the "ac" and
835  * "channel_layout" options, we need to check that the specified
836  * demuxer actually has the "channels" option before setting it */
837  if (file_iformat && file_iformat->priv_class &&
838  av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
840  av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
841  }
842  }
843  if (o->nb_frame_rates) {
844  /* set the format-level framerate option;
845  * this is important for video grabbers, e.g. x11 */
846  if (file_iformat && file_iformat->priv_class &&
847  av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
849  av_dict_set(&o->g->format_opts, "framerate",
850  o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
851  }
852  }
853  if (o->nb_frame_sizes) {
854  av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
855  }
856  if (o->nb_frame_pix_fmts)
857  av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
858 
859  MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
860  MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
861  MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
862  MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
863 
864  ic->video_codec_id = video_codec_name ?
865  find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
866  ic->audio_codec_id = audio_codec_name ?
867  find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
868  ic->subtitle_codec_id= subtitle_codec_name ?
869  find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
870  ic->data_codec_id = data_codec_name ?
871  find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0)->id : AV_CODEC_ID_NONE;
872 
873  if (video_codec_name)
874  av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
875  if (audio_codec_name)
876  av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
877  if (subtitle_codec_name)
879  if (data_codec_name)
881 
882  ic->flags |= AVFMT_FLAG_NONBLOCK;
884 
885  if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
886  av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
887  scan_all_pmts_set = 1;
888  }
889  /* open the input file with generic avformat function */
890  err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
891  if (err < 0) {
892  print_error(filename, err);
893  exit_program(1);
894  }
895  if (scan_all_pmts_set)
896  av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
899 
900  /* apply forced codec ids */
901  for (i = 0; i < ic->nb_streams; i++)
902  choose_decoder(o, ic, ic->streams[i]);
903 
904  /* Set AVCodecContext options for avformat_find_stream_info */
905  opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
906  orig_nb_streams = ic->nb_streams;
907 
908  /* If not enough info to get the stream parameters, we decode the
909  first frames to get it. (used in mpeg case for example) */
910  ret = avformat_find_stream_info(ic, opts);
911  if (ret < 0) {
912  av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
913  if (ic->nb_streams == 0) {
915  exit_program(1);
916  }
917  }
918 
919  timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
920  /* add the stream start time */
921  if (ic->start_time != AV_NOPTS_VALUE)
922  timestamp += ic->start_time;
923 
924  /* if seeking requested, we execute it */
925  if (o->start_time != AV_NOPTS_VALUE) {
926  ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, timestamp, 0);
927  if (ret < 0) {
928  av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
929  filename, (double)timestamp / AV_TIME_BASE);
930  }
931  }
932 
933  /* update the current parameters so that they match the one of the input stream */
934  add_input_streams(o, ic);
935 
936  /* dump the file content */
937  av_dump_format(ic, nb_input_files, filename, 0);
938 
940  f = av_mallocz(sizeof(*f));
941  if (!f)
942  exit_program(1);
943  input_files[nb_input_files - 1] = f;
944 
945  f->ctx = ic;
947  f->start_time = o->start_time;
950  f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
951  f->nb_streams = ic->nb_streams;
952  f->rate_emu = o->rate_emu;
954 #if HAVE_PTHREADS
956 #endif
957 
958  /* check if all codec options have been used */
959  unused_opts = strip_specifiers(o->g->codec_opts);
960  for (i = f->ist_index; i < nb_input_streams; i++) {
961  e = NULL;
962  while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
964  av_dict_set(&unused_opts, e->key, NULL, 0);
965  }
966 
967  e = NULL;
968  while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
969  const AVClass *class = avcodec_get_class();
970  const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
972  const AVClass *fclass = avformat_get_class();
973  const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
975  if (!option || foption)
976  continue;
977 
978 
979  if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
980  av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
981  "input file #%d (%s) is not a decoding option.\n", e->key,
982  option->help ? option->help : "", nb_input_files - 1,
983  filename);
984  exit_program(1);
985  }
986 
987  av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
988  "input file #%d (%s) has not been used for any stream. The most "
989  "likely reason is either wrong type (e.g. a video option with "
990  "no video streams) or that it is a private option of some decoder "
991  "which was not actually used for any stream.\n", e->key,
992  option->help ? option->help : "", nb_input_files - 1, filename);
993  }
994  av_dict_free(&unused_opts);
995 
996  for (i = 0; i < o->nb_dump_attachment; i++) {
997  int j;
998 
999  for (j = 0; j < ic->nb_streams; j++) {
1000  AVStream *st = ic->streams[j];
1001 
1002  if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1003  dump_attachment(st, o->dump_attachment[i].u.str);
1004  }
1005  }
1006 
1007  for (i = 0; i < orig_nb_streams; i++)
1008  av_dict_free(&opts[i]);
1009  av_freep(&opts);
1010 
1011  return 0;
1012 }
1013 
1015 {
1016  AVIOContext *line;
1017  uint8_t *buf;
1018  char c;
1019 
1020  if (avio_open_dyn_buf(&line) < 0) {
1021  av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1022  exit_program(1);
1023  }
1024 
1025  while ((c = avio_r8(s)) && c != '\n')
1026  avio_w8(line, c);
1027  avio_w8(line, 0);
1028  avio_close_dyn_buf(line, &buf);
1029 
1030  return buf;
1031 }
1032 
1033 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1034 {
1035  int i, ret = -1;
1036  char filename[1000];
1037  const char *base[3] = { getenv("AVCONV_DATADIR"),
1038  getenv("HOME"),
1040  };
1041 
1042  for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1043  if (!base[i])
1044  continue;
1045  if (codec_name) {
1046  snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1047  i != 1 ? "" : "/.avconv", codec_name, preset_name);
1048  ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1049  }
1050  if (ret < 0) {
1051  snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1052  i != 1 ? "" : "/.avconv", preset_name);
1053  ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1054  }
1055  }
1056  return ret;
1057 }
1058 
1060 {
1061  char *codec_name = NULL;
1062 
1063  MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1064  if (!codec_name) {
1065  ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1066  NULL, ost->st->codec->codec_type);
1067  ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1068  } else if (!strcmp(codec_name, "copy"))
1069  ost->stream_copy = 1;
1070  else {
1071  ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
1072  ost->st->codec->codec_id = ost->enc->id;
1073  }
1074 }
1075 
1077 {
1078  OutputStream *ost;
1079  AVStream *st = avformat_new_stream(oc, NULL);
1080  int idx = oc->nb_streams - 1, ret = 0;
1081  char *bsf = NULL, *next, *codec_tag = NULL;
1082  AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
1083  double qscale = -1;
1084  int i;
1085 
1086  if (!st) {
1087  av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1088  exit_program(1);
1089  }
1090 
1091  if (oc->nb_streams - 1 < o->nb_streamid_map)
1092  st->id = o->streamid_map[oc->nb_streams - 1];
1093 
1095  if (!(ost = av_mallocz(sizeof(*ost))))
1096  exit_program(1);
1097  output_streams[nb_output_streams - 1] = ost;
1098 
1099  ost->file_index = nb_output_files - 1;
1100  ost->index = idx;
1101  ost->st = st;
1102  st->codec->codec_type = type;
1103  choose_encoder(o, oc, ost);
1104 
1105  ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1106  if (!ost->enc_ctx) {
1107  av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1108  exit_program(1);
1109  }
1110  ost->enc_ctx->codec_type = type;
1111 
1112  if (ost->enc) {
1113  AVIOContext *s = NULL;
1114  char *buf = NULL, *arg = NULL, *preset = NULL;
1115 
1116  ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1117 
1118  MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1119  if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1120  do {
1121  buf = get_line(s);
1122  if (!buf[0] || buf[0] == '#') {
1123  av_free(buf);
1124  continue;
1125  }
1126  if (!(arg = strchr(buf, '='))) {
1127  av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1128  exit_program(1);
1129  }
1130  *arg++ = 0;
1132  av_free(buf);
1133  } while (!s->eof_reached);
1134  avio_closep(&s);
1135  }
1136  if (ret) {
1138  "Preset %s specified for stream %d:%d, but could not be opened.\n",
1139  preset, ost->file_index, ost->index);
1140  exit_program(1);
1141  }
1142  } else {
1144  }
1145 
1146  ost->max_frames = INT64_MAX;
1147  MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1148  for (i = 0; i<o->nb_max_frames; i++) {
1149  char *p = o->max_frames[i].specifier;
1150  if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1151  av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1152  break;
1153  }
1154  }
1155 
1156  ost->copy_prior_start = -1;
1157  MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1158 
1159  MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1160  while (bsf) {
1161  char *arg = NULL;
1162  if (next = strchr(bsf, ','))
1163  *next++ = 0;
1164  if (arg = strchr(bsf, '='))
1165  *arg++ = 0;
1166  if (!(bsfc = av_bitstream_filter_init(bsf))) {
1167  av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1168  exit_program(1);
1169  }
1170  if (bsfc_prev)
1171  bsfc_prev->next = bsfc;
1172  else
1173  ost->bitstream_filters = bsfc;
1174  av_dict_set(&ost->bsf_args, bsfc->filter->name, arg, 0);
1175 
1176  bsfc_prev = bsfc;
1177  bsf = next;
1178  }
1179 
1180  MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1181  if (codec_tag) {
1182  uint32_t tag = strtol(codec_tag, &next, 0);
1183  if (*next)
1184  tag = AV_RL32(codec_tag);
1185  ost->enc_ctx->codec_tag = tag;
1186  }
1187 
1188  MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1189  if (qscale >= 0) {
1190  ost->enc_ctx->flags |= CODEC_FLAG_QSCALE;
1191  ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1192  }
1193 
1194  MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1195  ost->disposition = av_strdup(ost->disposition);
1196 
1197  if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1199 
1200  av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1201 
1202  av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1203  if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1204  av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1205 
1206  av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1207 
1208  ost->source_index = source_index;
1209  if (source_index >= 0) {
1210  ost->sync_ist = input_streams[source_index];
1211  input_streams[source_index]->discard = 0;
1212  input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1213  }
1215 
1216  return ost;
1217 }
1218 
1219 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1220 {
1221  int i;
1222  const char *p = str;
1223  for (i = 0;; i++) {
1224  dest[i] = atoi(p);
1225  if (i == 63)
1226  break;
1227  p = strchr(p, ',');
1228  if (!p) {
1229  av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1230  exit_program(1);
1231  }
1232  p++;
1233  }
1234 }
1235 
1236 /* read file contents into a string */
1237 static uint8_t *read_file(const char *filename)
1238 {
1239  AVIOContext *pb = NULL;
1240  AVIOContext *dyn_buf = NULL;
1241  int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1242  uint8_t buf[1024], *str;
1243 
1244  if (ret < 0) {
1245  av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1246  return NULL;
1247  }
1248 
1249  ret = avio_open_dyn_buf(&dyn_buf);
1250  if (ret < 0) {
1251  avio_closep(&pb);
1252  return NULL;
1253  }
1254  while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1255  avio_write(dyn_buf, buf, ret);
1256  avio_w8(dyn_buf, 0);
1257  avio_closep(&pb);
1258 
1259  ret = avio_close_dyn_buf(dyn_buf, &str);
1260  if (ret < 0)
1261  return NULL;
1262  return str;
1263 }
1264 
1266  OutputStream *ost)
1267 {
1268  AVStream *st = ost->st;
1269 
1270  if (ost->filters_script && ost->filters) {
1271  av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1272  "output stream #%d:%d.\n", nb_output_files, st->index);
1273  exit_program(1);
1274  }
1275 
1276  if (ost->filters_script)
1277  return read_file(ost->filters_script);
1278  else if (ost->filters)
1279  return av_strdup(ost->filters);
1280 
1281  return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1282  "null" : "anull");
1283 }
1284 
1286  const OutputStream *ost, enum AVMediaType type)
1287 {
1288  if (ost->filters_script || ost->filters) {
1290  "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1291  "Filtering and streamcopy cannot be used together.\n",
1292  ost->filters ? "Filtergraph" : "Filtergraph script",
1293  ost->filters ? ost->filters : ost->filters_script,
1294  av_get_media_type_string(type), ost->file_index, ost->index);
1295  exit_program(1);
1296  }
1297 }
1298 
1300 {
1301  AVStream *st;
1302  OutputStream *ost;
1303  AVCodecContext *video_enc;
1304  char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1305 
1306  ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1307  st = ost->st;
1308  video_enc = ost->enc_ctx;
1309 
1310  MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1311  if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1312  av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1313  exit_program(1);
1314  }
1315  if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1316  av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1317 
1318  MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1319  if (frame_aspect_ratio) {
1320  AVRational q;
1321  if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1322  q.num <= 0 || q.den <= 0) {
1323  av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1324  exit_program(1);
1325  }
1326  ost->frame_aspect_ratio = q;
1327  }
1328 
1329  MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1330  MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1331 
1332  if (!ost->stream_copy) {
1333  const char *p = NULL;
1334  char *frame_size = NULL;
1335  char *frame_pix_fmt = NULL;
1336  char *intra_matrix = NULL, *inter_matrix = NULL;
1337  char *chroma_intra_matrix = NULL;
1338  int do_pass = 0;
1339  int i;
1340 
1341  MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1342  if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1343  av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1344  exit_program(1);
1345  }
1346 
1348  MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1349  if (frame_pix_fmt && *frame_pix_fmt == '+') {
1350  ost->keep_pix_fmt = 1;
1351  if (!*++frame_pix_fmt)
1352  frame_pix_fmt = NULL;
1353  }
1354  if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1355  av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1356  exit_program(1);
1357  }
1358  st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1359 
1360  if (intra_only)
1361  video_enc->gop_size = 0;
1362  MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1363  if (intra_matrix) {
1364  if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1365  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1366  exit_program(1);
1367  }
1368  parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1369  }
1370  MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1371  if (chroma_intra_matrix) {
1372  uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1373  if (!p) {
1374  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1375  exit_program(1);
1376  }
1377  av_codec_set_chroma_intra_matrix(video_enc, p);
1378  parse_matrix_coeffs(p, chroma_intra_matrix);
1379  }
1380  MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1381  if (inter_matrix) {
1382  if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1383  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1384  exit_program(1);
1385  }
1386  parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1387  }
1388 
1389  MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1390  for (i = 0; p; i++) {
1391  int start, end, q;
1392  int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1393  if (e != 3) {
1394  av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1395  exit_program(1);
1396  }
1397  video_enc->rc_override =
1398  av_realloc_array(video_enc->rc_override,
1399  i + 1, sizeof(RcOverride));
1400  if (!video_enc->rc_override) {
1401  av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1402  exit_program(1);
1403  }
1404  video_enc->rc_override[i].start_frame = start;
1405  video_enc->rc_override[i].end_frame = end;
1406  if (q > 0) {
1407  video_enc->rc_override[i].qscale = q;
1408  video_enc->rc_override[i].quality_factor = 1.0;
1409  }
1410  else {
1411  video_enc->rc_override[i].qscale = 0;
1412  video_enc->rc_override[i].quality_factor = -q/100.0;
1413  }
1414  p = strchr(p, '/');
1415  if (p) p++;
1416  }
1417  video_enc->rc_override_count = i;
1418 
1419  if (do_psnr)
1420  video_enc->flags|= CODEC_FLAG_PSNR;
1421 
1422  /* two pass mode */
1423  MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1424  if (do_pass) {
1425  if (do_pass & 1) {
1426  video_enc->flags |= CODEC_FLAG_PASS1;
1427  av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1428  }
1429  if (do_pass & 2) {
1430  video_enc->flags |= CODEC_FLAG_PASS2;
1431  av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1432  }
1433  }
1434 
1435  MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1436  if (ost->logfile_prefix &&
1437  !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1438  exit_program(1);
1439 
1440  MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1441  if (ost->forced_keyframes)
1443 
1444  MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1445 
1446  ost->top_field_first = -1;
1447  MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1448 
1449 
1450  ost->avfilter = get_ost_filters(o, oc, ost);
1451  if (!ost->avfilter)
1452  exit_program(1);
1453  } else {
1454  MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1455  }
1456 
1457  if (ost->stream_copy)
1459 
1460  return ost;
1461 }
1462 
1464 {
1465  int n;
1466  AVStream *st;
1467  OutputStream *ost;
1468  AVCodecContext *audio_enc;
1469 
1470  ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1471  st = ost->st;
1472 
1473  audio_enc = ost->enc_ctx;
1474  audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1475 
1476  MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1477  MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1478 
1479  if (!ost->stream_copy) {
1480  char *sample_fmt = NULL;
1481 
1482  MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1483 
1484  MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1485  if (sample_fmt &&
1486  (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1487  av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1488  exit_program(1);
1489  }
1490 
1491  MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1492 
1493  MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1494  ost->apad = av_strdup(ost->apad);
1495 
1496  ost->avfilter = get_ost_filters(o, oc, ost);
1497  if (!ost->avfilter)
1498  exit_program(1);
1499 
1500  /* check for channel mapping for this audio stream */
1501  for (n = 0; n < o->nb_audio_channel_maps; n++) {
1502  AudioChannelMap *map = &o->audio_channel_maps[n];
1503  if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1504  (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1505  InputStream *ist;
1506 
1507  if (map->channel_idx == -1) {
1508  ist = NULL;
1509  } else if (ost->source_index < 0) {
1510  av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1511  ost->file_index, ost->st->index);
1512  continue;
1513  } else {
1514  ist = input_streams[ost->source_index];
1515  }
1516 
1517  if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1519  ost->audio_channels_mapped + 1,
1520  sizeof(*ost->audio_channels_map)
1521  ) < 0 )
1522  exit_program(1);
1523 
1525  }
1526  }
1527  }
1528  }
1529 
1530  if (ost->stream_copy)
1532 
1533  return ost;
1534 }
1535 
1537 {
1538  OutputStream *ost;
1539 
1540  ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1541  if (!ost->stream_copy) {
1542  av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1543  exit_program(1);
1544  }
1545 
1546  return ost;
1547 }
1548 
1550 {
1551  OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1552  ost->stream_copy = 1;
1553  ost->finished = 1;
1554  return ost;
1555 }
1556 
1558 {
1559  AVStream *st;
1560  OutputStream *ost;
1561  AVCodecContext *subtitle_enc;
1562 
1563  ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1564  st = ost->st;
1565  subtitle_enc = ost->enc_ctx;
1566 
1567  subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1568 
1569  MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1570 
1571  if (!ost->stream_copy) {
1572  char *frame_size = NULL;
1573 
1574  MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1575  if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1576  av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1577  exit_program(1);
1578  }
1579  }
1580 
1581  return ost;
1582 }
1583 
1584 /* arg format is "output-stream-index:streamid-value". */
1585 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1586 {
1587  OptionsContext *o = optctx;
1588  int idx;
1589  char *p;
1590  char idx_str[16];
1591 
1592  av_strlcpy(idx_str, arg, sizeof(idx_str));
1593  p = strchr(idx_str, ':');
1594  if (!p) {
1596  "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1597  arg, opt);
1598  exit_program(1);
1599  }
1600  *p++ = '\0';
1601  idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1602  o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1603  o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1604  return 0;
1605 }
1606 
1608 {
1609  AVFormatContext *is = ifile->ctx;
1610  AVFormatContext *os = ofile->ctx;
1611  AVChapter **tmp;
1612  int i;
1613 
1614  tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1615  if (!tmp)
1616  return AVERROR(ENOMEM);
1617  os->chapters = tmp;
1618 
1619  for (i = 0; i < is->nb_chapters; i++) {
1620  AVChapter *in_ch = is->chapters[i], *out_ch;
1621  int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1622  int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1623  AV_TIME_BASE_Q, in_ch->time_base);
1624  int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1626 
1627 
1628  if (in_ch->end < ts_off)
1629  continue;
1630  if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1631  break;
1632 
1633  out_ch = av_mallocz(sizeof(AVChapter));
1634  if (!out_ch)
1635  return AVERROR(ENOMEM);
1636 
1637  out_ch->id = in_ch->id;
1638  out_ch->time_base = in_ch->time_base;
1639  out_ch->start = FFMAX(0, in_ch->start - ts_off);
1640  out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1641 
1642  if (copy_metadata)
1643  av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1644 
1645  os->chapters[os->nb_chapters++] = out_ch;
1646  }
1647  return 0;
1648 }
1649 
1650 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1651 {
1652  int i, err;
1654 
1655  ic->interrupt_callback = int_cb;
1656  err = avformat_open_input(&ic, filename, NULL, NULL);
1657  if (err < 0)
1658  return err;
1659  /* copy stream format */
1660  for(i=0;i<ic->nb_streams;i++) {
1661  AVStream *st;
1662  OutputStream *ost;
1663  AVCodec *codec;
1664  const char *enc_config;
1665 
1666  codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1667  if (!codec) {
1668  av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codec->codec_id);
1669  return AVERROR(EINVAL);
1670  }
1671  if (codec->type == AVMEDIA_TYPE_AUDIO)
1672  opt_audio_codec(o, "c:a", codec->name);
1673  else if (codec->type == AVMEDIA_TYPE_VIDEO)
1674  opt_video_codec(o, "c:v", codec->name);
1675  ost = new_output_stream(o, s, codec->type, -1);
1676  st = ost->st;
1677 
1680  if (enc_config) {
1681  AVDictionary *opts = NULL;
1682  av_dict_parse_string(&opts, enc_config, "=", ",", 0);
1684  av_dict_free(&opts);
1685  }
1686 
1687  if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1688  choose_sample_fmt(st, codec);
1689  else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1690  choose_pixel_fmt(st, st->codec, codec, st->codec->pix_fmt);
1691  avcodec_copy_context(ost->enc_ctx, st->codec);
1692  if (enc_config)
1693  av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
1694  }
1695 
1696  avformat_close_input(&ic);
1697  return err;
1698 }
1699 
1701  AVFormatContext *oc)
1702 {
1703  OutputStream *ost;
1704 
1706  ofilter->out_tmp->pad_idx)) {
1707  case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1708  case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1709  default:
1710  av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1711  "currently.\n");
1712  exit_program(1);
1713  }
1714 
1715  ost->source_index = -1;
1716  ost->filter = ofilter;
1717 
1718  ofilter->ost = ost;
1719 
1720  if (ost->stream_copy) {
1721  av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1722  "which is fed from a complex filtergraph. Filtering and streamcopy "
1723  "cannot be used together.\n", ost->file_index, ost->index);
1724  exit_program(1);
1725  }
1726 
1727  if (ost->avfilter && (ost->filters || ost->filters_script)) {
1728  const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1730  "%s '%s' was specified through the %s option "
1731  "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1732  "%s and -filter_complex cannot be used together for the same stream.\n",
1733  ost->filters ? "Filtergraph" : "Filtergraph script",
1734  ost->filters ? ost->filters : ost->filters_script,
1735  opt, ost->file_index, ost->index, opt);
1736  exit_program(1);
1737  }
1738 
1739  if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1740  av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1741  exit_program(1);
1742  }
1743  avfilter_inout_free(&ofilter->out_tmp);
1744 }
1745 
1747 {
1748  int i, ret = 0;
1749 
1750  for (i = 0; i < nb_filtergraphs; i++)
1751  if (!filtergraphs[i]->graph &&
1752  (ret = configure_filtergraph(filtergraphs[i])) < 0)
1753  return ret;
1754  return 0;
1755 }
1756 
1757 static int open_output_file(OptionsContext *o, const char *filename)
1758 {
1759  AVFormatContext *oc;
1760  int i, j, err;
1761  AVOutputFormat *file_oformat;
1762  OutputFile *of;
1763  OutputStream *ost;
1764  InputStream *ist;
1765  AVDictionary *unused_opts = NULL;
1766  AVDictionaryEntry *e = NULL;
1767 
1768  if (configure_complex_filters() < 0) {
1769  av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1770  exit_program(1);
1771  }
1772 
1773  if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1774  o->stop_time = INT64_MAX;
1775  av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1776  }
1777 
1778  if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1779  int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1780  if (o->stop_time <= start_time) {
1781  av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1782  exit_program(1);
1783  } else {
1785  }
1786  }
1787 
1789  of = av_mallocz(sizeof(*of));
1790  if (!of)
1791  exit_program(1);
1792  output_files[nb_output_files - 1] = of;
1793 
1795  of->recording_time = o->recording_time;
1796  of->start_time = o->start_time;
1797  of->limit_filesize = o->limit_filesize;
1798  of->shortest = o->shortest;
1799  av_dict_copy(&of->opts, o->g->format_opts, 0);
1800 
1801  if (!strcmp(filename, "-"))
1802  filename = "pipe:";
1803 
1804  err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1805  if (!oc) {
1806  print_error(filename, err);
1807  exit_program(1);
1808  }
1809 
1810  of->ctx = oc;
1811  if (o->recording_time != INT64_MAX)
1812  oc->duration = o->recording_time;
1813 
1814  file_oformat= oc->oformat;
1815  oc->interrupt_callback = int_cb;
1816 
1817  /* create streams for all unlabeled output pads */
1818  for (i = 0; i < nb_filtergraphs; i++) {
1819  FilterGraph *fg = filtergraphs[i];
1820  for (j = 0; j < fg->nb_outputs; j++) {
1821  OutputFilter *ofilter = fg->outputs[j];
1822 
1823  if (!ofilter->out_tmp || ofilter->out_tmp->name)
1824  continue;
1825 
1827  ofilter->out_tmp->pad_idx)) {
1828  case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1829  case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1830  case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1831  }
1832  init_output_filter(ofilter, o, oc);
1833  }
1834  }
1835 
1836  /* ffserver seeking with date=... needs a date reference */
1837  if (!strcmp(file_oformat->name, "ffm") &&
1838  av_strstart(filename, "http:", NULL)) {
1839  int err = parse_option(o, "metadata", "creation_time=now", options);
1840  if (err < 0) {
1841  print_error(filename, err);
1842  exit_program(1);
1843  }
1844  }
1845 
1846  if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1847  av_strstart(filename, "http:", NULL)) {
1848  int j;
1849  /* special case for files sent to ffserver: we get the stream
1850  parameters from ffserver */
1851  int err = read_ffserver_streams(o, oc, filename);
1852  if (err < 0) {
1853  print_error(filename, err);
1854  exit_program(1);
1855  }
1856  for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1857  ost = output_streams[j];
1858  for (i = 0; i < nb_input_streams; i++) {
1859  ist = input_streams[i];
1860  if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1861  ost->sync_ist= ist;
1862  ost->source_index= i;
1863  if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1864  if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1865  ist->discard = 0;
1866  ist->st->discard = ist->user_set_discard;
1867  break;
1868  }
1869  }
1870  if(!ost->sync_ist){
1871  av_log(NULL, AV_LOG_FATAL, "Missing %s stream which is required by this ffm\n", av_get_media_type_string(ost->st->codec->codec_type));
1872  exit_program(1);
1873  }
1874  }
1875  } else if (!o->nb_stream_maps) {
1876  char *subtitle_codec_name = NULL;
1877  /* pick the "best" stream of each type */
1878 
1879  /* video: highest resolution */
1881  int area = 0, idx = -1;
1882  int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1883  for (i = 0; i < nb_input_streams; i++) {
1884  int new_area;
1885  ist = input_streams[i];
1886  new_area = ist->st->codec->width * ist->st->codec->height;
1887  if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1888  new_area = 1;
1889  if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1890  new_area > area) {
1891  if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1892  continue;
1893  area = new_area;
1894  idx = i;
1895  }
1896  }
1897  if (idx >= 0)
1898  new_video_stream(o, oc, idx);
1899  }
1900 
1901  /* audio: most channels */
1903  int channels = 0, idx = -1;
1904  for (i = 0; i < nb_input_streams; i++) {
1905  ist = input_streams[i];
1906  if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1907  ist->st->codec->channels > channels) {
1908  channels = ist->st->codec->channels;
1909  idx = i;
1910  }
1911  }
1912  if (idx >= 0)
1913  new_audio_stream(o, oc, idx);
1914  }
1915 
1916  /* subtitles: pick first */
1917  MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1918  if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
1919  for (i = 0; i < nb_input_streams; i++)
1920  if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1921  AVCodecDescriptor const *input_descriptor =
1922  avcodec_descriptor_get(input_streams[i]->st->codec->codec_id);
1923  AVCodecDescriptor const *output_descriptor = NULL;
1924  AVCodec const *output_codec =
1926  int input_props = 0, output_props = 0;
1927  if (output_codec)
1928  output_descriptor = avcodec_descriptor_get(output_codec->id);
1929  if (input_descriptor)
1930  input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1931  if (output_descriptor)
1932  output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1933  if (subtitle_codec_name ||
1934  input_props & output_props ||
1935  // Map dvb teletext which has neither property to any output subtitle encoder
1936  input_descriptor && output_descriptor &&
1937  (!input_descriptor->props ||
1938  !output_descriptor->props)) {
1939  new_subtitle_stream(o, oc, i);
1940  break;
1941  }
1942  }
1943  }
1944  /* Data only if codec id match */
1945  if (!o->data_disable ) {
1947  for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
1948  if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_DATA
1949  && input_streams[i]->st->codec->codec_id == codec_id )
1950  new_data_stream(o, oc, i);
1951  }
1952  }
1953  } else {
1954  for (i = 0; i < o->nb_stream_maps; i++) {
1955  StreamMap *map = &o->stream_maps[i];
1956 
1957  if (map->disabled)
1958  continue;
1959 
1960  if (map->linklabel) {
1961  FilterGraph *fg;
1962  OutputFilter *ofilter = NULL;
1963  int j, k;
1964 
1965  for (j = 0; j < nb_filtergraphs; j++) {
1966  fg = filtergraphs[j];
1967  for (k = 0; k < fg->nb_outputs; k++) {
1968  AVFilterInOut *out = fg->outputs[k]->out_tmp;
1969  if (out && !strcmp(out->name, map->linklabel)) {
1970  ofilter = fg->outputs[k];
1971  goto loop_end;
1972  }
1973  }
1974  }
1975 loop_end:
1976  if (!ofilter) {
1977  av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1978  "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1979  exit_program(1);
1980  }
1981  init_output_filter(ofilter, o, oc);
1982  } else {
1983  int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1984 
1987  continue;
1988  if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1989  continue;
1990  if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1991  continue;
1992  if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1993  continue;
1994 
1995  switch (ist->st->codec->codec_type) {
1996  case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1997  case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1998  case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1999  case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2000  case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2001  default:
2002  av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
2003  map->file_index, map->stream_index);
2004  exit_program(1);
2005  }
2006  }
2007  }
2008  }
2009 
2010  /* handle attached files */
2011  for (i = 0; i < o->nb_attachments; i++) {
2012  AVIOContext *pb;
2013  uint8_t *attachment;
2014  const char *p;
2015  int64_t len;
2016 
2017  if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2018  av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2019  o->attachments[i]);
2020  exit_program(1);
2021  }
2022  if ((len = avio_size(pb)) <= 0) {
2023  av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2024  o->attachments[i]);
2025  exit_program(1);
2026  }
2027  if (!(attachment = av_malloc(len))) {
2028  av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2029  o->attachments[i]);
2030  exit_program(1);
2031  }
2032  avio_read(pb, attachment, len);
2033 
2034  ost = new_attachment_stream(o, oc, -1);
2035  ost->stream_copy = 0;
2036  ost->attachment_filename = o->attachments[i];
2037  ost->finished = 1;
2038  ost->enc_ctx->extradata = attachment;
2039  ost->enc_ctx->extradata_size = len;
2040 
2041  p = strrchr(o->attachments[i], '/');
2042  av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2043  avio_closep(&pb);
2044  }
2045 
2046  for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2047  AVDictionaryEntry *e;
2048  ost = output_streams[i];
2049 
2050  if ((ost->stream_copy || ost->attachment_filename)
2051  && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2052  && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2053  if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2054  exit_program(1);
2055  }
2056 
2057  /* check if all codec options have been used */
2058  unused_opts = strip_specifiers(o->g->codec_opts);
2059  for (i = of->ost_index; i < nb_output_streams; i++) {
2060  e = NULL;
2061  while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2063  av_dict_set(&unused_opts, e->key, NULL, 0);
2064  }
2065 
2066  e = NULL;
2067  while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2068  const AVClass *class = avcodec_get_class();
2069  const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2071  const AVClass *fclass = avformat_get_class();
2072  const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2074  if (!option || foption)
2075  continue;
2076 
2077 
2078  if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2079  av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2080  "output file #%d (%s) is not an encoding option.\n", e->key,
2081  option->help ? option->help : "", nb_output_files - 1,
2082  filename);
2083  exit_program(1);
2084  }
2085 
2086  // gop_timecode is injected by generic code but not always used
2087  if (!strcmp(e->key, "gop_timecode"))
2088  continue;
2089 
2090  av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2091  "output file #%d (%s) has not been used for any stream. The most "
2092  "likely reason is either wrong type (e.g. a video option with "
2093  "no video streams) or that it is a private option of some encoder "
2094  "which was not actually used for any stream.\n", e->key,
2095  option->help ? option->help : "", nb_output_files - 1, filename);
2096  }
2097  av_dict_free(&unused_opts);
2098 
2099  /* check filename in case of an image number is expected */
2100  if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2101  if (!av_filename_number_test(oc->filename)) {
2102  print_error(oc->filename, AVERROR(EINVAL));
2103  exit_program(1);
2104  }
2105  }
2106 
2107  if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2108  /* test if it already exists to avoid losing precious files */
2109  assert_file_overwrite(filename);
2110 
2111  /* open the file */
2112  if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2113  &oc->interrupt_callback,
2114  &of->opts)) < 0) {
2115  print_error(filename, err);
2116  exit_program(1);
2117  }
2118  } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2119  assert_file_overwrite(filename);
2120 
2121  if (o->mux_preload) {
2122  av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2123  }
2124  oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2125 
2126  /* copy metadata */
2127  for (i = 0; i < o->nb_metadata_map; i++) {
2128  char *p;
2129  int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2130 
2131  if (in_file_index >= nb_input_files) {
2132  av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2133  exit_program(1);
2134  }
2135  copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2136  in_file_index >= 0 ?
2137  input_files[in_file_index]->ctx : NULL, o);
2138  }
2139 
2140  /* copy chapters */
2141  if (o->chapters_input_file >= nb_input_files) {
2142  if (o->chapters_input_file == INT_MAX) {
2143  /* copy chapters from the first input file that has them*/
2144  o->chapters_input_file = -1;
2145  for (i = 0; i < nb_input_files; i++)
2146  if (input_files[i]->ctx->nb_chapters) {
2147  o->chapters_input_file = i;
2148  break;
2149  }
2150  } else {
2151  av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2152  o->chapters_input_file);
2153  exit_program(1);
2154  }
2155  }
2156  if (o->chapters_input_file >= 0)
2159 
2160  /* copy global metadata by default */
2164  if(o->recording_time != INT64_MAX)
2165  av_dict_set(&oc->metadata, "duration", NULL, 0);
2166  av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2167  }
2168  if (!o->metadata_streams_manual)
2169  for (i = of->ost_index; i < nb_output_streams; i++) {
2170  InputStream *ist;
2171  if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2172  continue;
2174  av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2175  if (!output_streams[i]->stream_copy)
2176  av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2177  }
2178 
2179  /* process manually set metadata */
2180  for (i = 0; i < o->nb_metadata; i++) {
2181  AVDictionary **m;
2182  char type, *val;
2183  const char *stream_spec;
2184  int index = 0, j, ret = 0;
2185 
2186  val = strchr(o->metadata[i].u.str, '=');
2187  if (!val) {
2188  av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2189  o->metadata[i].u.str);
2190  exit_program(1);
2191  }
2192  *val++ = 0;
2193 
2194  parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2195  if (type == 's') {
2196  for (j = 0; j < oc->nb_streams; j++) {
2197  if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2198  av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2199  } else if (ret < 0)
2200  exit_program(1);
2201  }
2202  }
2203  else {
2204  switch (type) {
2205  case 'g':
2206  m = &oc->metadata;
2207  break;
2208  case 'c':
2209  if (index < 0 || index >= oc->nb_chapters) {
2210  av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2211  exit_program(1);
2212  }
2213  m = &oc->chapters[index]->metadata;
2214  break;
2215  default:
2216  av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2217  exit_program(1);
2218  }
2219  av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2220  }
2221  }
2222 
2223  return 0;
2224 }
2225 
2226 static int opt_target(void *optctx, const char *opt, const char *arg)
2227 {
2228  OptionsContext *o = optctx;
2229  enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2230  static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2231 
2232  if (!strncmp(arg, "pal-", 4)) {
2233  norm = PAL;
2234  arg += 4;
2235  } else if (!strncmp(arg, "ntsc-", 5)) {
2236  norm = NTSC;
2237  arg += 5;
2238  } else if (!strncmp(arg, "film-", 5)) {
2239  norm = FILM;
2240  arg += 5;
2241  } else {
2242  /* Try to determine PAL/NTSC by peeking in the input files */
2243  if (nb_input_files) {
2244  int i, j, fr;
2245  for (j = 0; j < nb_input_files; j++) {
2246  for (i = 0; i < input_files[j]->nb_streams; i++) {
2248  if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2249  !c->time_base.num)
2250  continue;
2251  fr = c->time_base.den * 1000 / c->time_base.num;
2252  if (fr == 25000) {
2253  norm = PAL;
2254  break;
2255  } else if ((fr == 29970) || (fr == 23976)) {
2256  norm = NTSC;
2257  break;
2258  }
2259  }
2260  if (norm != UNKNOWN)
2261  break;
2262  }
2263  }
2264  if (norm != UNKNOWN)
2265  av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2266  }
2267 
2268  if (norm == UNKNOWN) {
2269  av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2270  av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2271  av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2272  exit_program(1);
2273  }
2274 
2275  if (!strcmp(arg, "vcd")) {
2276  opt_video_codec(o, "c:v", "mpeg1video");
2277  opt_audio_codec(o, "c:a", "mp2");
2278  parse_option(o, "f", "vcd", options);
2279 
2280  parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2281  parse_option(o, "r", frame_rates[norm], options);
2282  opt_default(NULL, "g", norm == PAL ? "15" : "18");
2283 
2284  opt_default(NULL, "b:v", "1150000");
2285  opt_default(NULL, "maxrate:v", "1150000");
2286  opt_default(NULL, "minrate:v", "1150000");
2287  opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2288 
2289  opt_default(NULL, "b:a", "224000");
2290  parse_option(o, "ar", "44100", options);
2291  parse_option(o, "ac", "2", options);
2292 
2293  opt_default(NULL, "packetsize", "2324");
2294  opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2295 
2296  /* We have to offset the PTS, so that it is consistent with the SCR.
2297  SCR starts at 36000, but the first two packs contain only padding
2298  and the first pack from the other stream, respectively, may also have
2299  been written before.
2300  So the real data starts at SCR 36000+3*1200. */
2301  o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2302  } else if (!strcmp(arg, "svcd")) {
2303 
2304  opt_video_codec(o, "c:v", "mpeg2video");
2305  opt_audio_codec(o, "c:a", "mp2");
2306  parse_option(o, "f", "svcd", options);
2307 
2308  parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2309  parse_option(o, "r", frame_rates[norm], options);
2310  parse_option(o, "pix_fmt", "yuv420p", options);
2311  opt_default(NULL, "g", norm == PAL ? "15" : "18");
2312 
2313  opt_default(NULL, "b:v", "2040000");
2314  opt_default(NULL, "maxrate:v", "2516000");
2315  opt_default(NULL, "minrate:v", "0"); // 1145000;
2316  opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2317  opt_default(NULL, "scan_offset", "1");
2318 
2319  opt_default(NULL, "b:a", "224000");
2320  parse_option(o, "ar", "44100", options);
2321 
2322  opt_default(NULL, "packetsize", "2324");
2323 
2324  } else if (!strcmp(arg, "dvd")) {
2325 
2326  opt_video_codec(o, "c:v", "mpeg2video");
2327  opt_audio_codec(o, "c:a", "ac3");
2328  parse_option(o, "f", "dvd", options);
2329 
2330  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2331  parse_option(o, "r", frame_rates[norm], options);
2332  parse_option(o, "pix_fmt", "yuv420p", options);
2333  opt_default(NULL, "g", norm == PAL ? "15" : "18");
2334 
2335  opt_default(NULL, "b:v", "6000000");
2336  opt_default(NULL, "maxrate:v", "9000000");
2337  opt_default(NULL, "minrate:v", "0"); // 1500000;
2338  opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2339 
2340  opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2341  opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2342 
2343  opt_default(NULL, "b:a", "448000");
2344  parse_option(o, "ar", "48000", options);
2345 
2346  } else if (!strncmp(arg, "dv", 2)) {
2347 
2348  parse_option(o, "f", "dv", options);
2349 
2350  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2351  parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2352  norm == PAL ? "yuv420p" : "yuv411p", options);
2353  parse_option(o, "r", frame_rates[norm], options);
2354 
2355  parse_option(o, "ar", "48000", options);
2356  parse_option(o, "ac", "2", options);
2357 
2358  } else {
2359  av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2360  return AVERROR(EINVAL);
2361  }
2362 
2365 
2366  return 0;
2367 }
2368 
2369 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2370 {
2372  vstats_filename = av_strdup (arg);
2373  return 0;
2374 }
2375 
2376 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2377 {
2378  char filename[40];
2379  time_t today2 = time(NULL);
2380  struct tm *today = localtime(&today2);
2381 
2382  if (!today)
2383  return AVERROR(errno);
2384 
2385  snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2386  today->tm_sec);
2387  return opt_vstats_file(NULL, opt, filename);
2388 }
2389 
2390 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2391 {
2392  OptionsContext *o = optctx;
2393  return parse_option(o, "frames:v", arg, options);
2394 }
2395 
2396 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2397 {
2398  OptionsContext *o = optctx;
2399  return parse_option(o, "frames:a", arg, options);
2400 }
2401 
2402 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2403 {
2404  OptionsContext *o = optctx;
2405  return parse_option(o, "frames:d", arg, options);
2406 }
2407 
2408 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2409 {
2410  int ret;
2411  AVDictionary *cbak = codec_opts;
2412  AVDictionary *fbak = format_opts;
2413  codec_opts = NULL;
2414  format_opts = NULL;
2415 
2416  ret = opt_default(NULL, opt, arg);
2417 
2418  av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2422  codec_opts = cbak;
2423  format_opts = fbak;
2424 
2425  return ret;
2426 }
2427 
2428 static int opt_preset(void *optctx, const char *opt, const char *arg)
2429 {
2430  OptionsContext *o = optctx;
2431  FILE *f=NULL;
2432  char filename[1000], line[1000], tmp_line[1000];
2433  const char *codec_name = NULL;
2434 
2435  tmp_line[0] = *opt;
2436  tmp_line[1] = 0;
2437  MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2438 
2439  if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2440  if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2441  av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2442  }else
2443  av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2444  exit_program(1);
2445  }
2446 
2447  while (fgets(line, sizeof(line), f)) {
2448  char *key = tmp_line, *value, *endptr;
2449 
2450  if (strcspn(line, "#\n\r") == 0)
2451  continue;
2452  av_strlcpy(tmp_line, line, sizeof(tmp_line));
2453  if (!av_strtok(key, "=", &value) ||
2454  !av_strtok(value, "\r\n", &endptr)) {
2455  av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2456  exit_program(1);
2457  }
2458  av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2459 
2460  if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2461  else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2462  else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2463  else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2464  else if (opt_default_new(o, key, value) < 0) {
2465  av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2466  filename, line, key, value);
2467  exit_program(1);
2468  }
2469  }
2470 
2471  fclose(f);
2472 
2473  return 0;
2474 }
2475 
2476 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2477 {
2478  OptionsContext *o = optctx;
2479  char *s = av_asprintf("%s:%c", opt + 1, *opt);
2480  int ret = parse_option(o, s, arg, options);
2481  av_free(s);
2482  return ret;
2483 }
2484 
2485 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2486 {
2487  OptionsContext *o = optctx;
2488 
2489  if(!strcmp(opt, "ab")){
2490  av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2491  return 0;
2492  } else if(!strcmp(opt, "b")){
2493  av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2494  av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2495  return 0;
2496  }
2497  av_dict_set(&o->g->codec_opts, opt, arg, 0);
2498  return 0;
2499 }
2500 
2501 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2502 {
2503  OptionsContext *o = optctx;
2504  char *s;
2505  int ret;
2506  if(!strcmp(opt, "qscale")){
2507  av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2508  return parse_option(o, "q:v", arg, options);
2509  }
2510  s = av_asprintf("q%s", opt + 6);
2511  ret = parse_option(o, s, arg, options);
2512  av_free(s);
2513  return ret;
2514 }
2515 
2516 static int opt_profile(void *optctx, const char *opt, const char *arg)
2517 {
2518  OptionsContext *o = optctx;
2519  if(!strcmp(opt, "profile")){
2520  av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2521  av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2522  return 0;
2523  }
2524  av_dict_set(&o->g->codec_opts, opt, arg, 0);
2525  return 0;
2526 }
2527 
2528 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2529 {
2530  OptionsContext *o = optctx;
2531  return parse_option(o, "filter:v", arg, options);
2532 }
2533 
2534 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2535 {
2536  OptionsContext *o = optctx;
2537  return parse_option(o, "filter:a", arg, options);
2538 }
2539 
2540 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2541 {
2542  if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2543  else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2544  else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2545  else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2546 
2549  return 0;
2550 }
2551 
2552 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2553 {
2554  OptionsContext *o = optctx;
2555  char *tcr = av_asprintf("timecode=%s", arg);
2556  int ret = parse_option(o, "metadata:g", tcr, options);
2557  if (ret >= 0)
2558  ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2559  av_free(tcr);
2560  return 0;
2561 }
2562 
2563 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2564 {
2565  OptionsContext *o = optctx;
2566  char layout_str[32];
2567  char *stream_str;
2568  char *ac_str;
2569  int ret, channels, ac_str_size;
2570  uint64_t layout;
2571 
2572  layout = av_get_channel_layout(arg);
2573  if (!layout) {
2574  av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2575  return AVERROR(EINVAL);
2576  }
2577  snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2578  ret = opt_default_new(o, opt, layout_str);
2579  if (ret < 0)
2580  return ret;
2581 
2582  /* set 'ac' option based on channel layout */
2583  channels = av_get_channel_layout_nb_channels(layout);
2584  snprintf(layout_str, sizeof(layout_str), "%d", channels);
2585  stream_str = strchr(opt, ':');
2586  ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2587  ac_str = av_mallocz(ac_str_size);
2588  if (!ac_str)
2589  return AVERROR(ENOMEM);
2590  av_strlcpy(ac_str, "ac", 3);
2591  if (stream_str)
2592  av_strlcat(ac_str, stream_str, ac_str_size);
2593  ret = parse_option(o, ac_str, layout_str, options);
2594  av_free(ac_str);
2595 
2596  return ret;
2597 }
2598 
2599 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2600 {
2601  OptionsContext *o = optctx;
2602  return parse_option(o, "q:a", arg, options);
2603 }
2604 
2605 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2606 {
2608  if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2609  return AVERROR(ENOMEM);
2612  if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2613  return AVERROR(ENOMEM);
2614  return 0;
2615 }
2616 
2617 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2618 {
2619  uint8_t *graph_desc = read_file(arg);
2620  if (!graph_desc)
2621  return AVERROR(EINVAL);
2622 
2624  if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2625  return AVERROR(ENOMEM);
2627  filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2628  return 0;
2629 }
2630 
2631 void show_help_default(const char *opt, const char *arg)
2632 {
2633  /* per-file options have at least one of those set */
2634  const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2635  int show_advanced = 0, show_avoptions = 0;
2636 
2637  if (opt && *opt) {
2638  if (!strcmp(opt, "long"))
2639  show_advanced = 1;
2640  else if (!strcmp(opt, "full"))
2641  show_advanced = show_avoptions = 1;
2642  else
2643  av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2644  }
2645 
2646  show_usage();
2647 
2648  printf("Getting help:\n"
2649  " -h -- print basic options\n"
2650  " -h long -- print more options\n"
2651  " -h full -- print all options (including all format and codec specific options, very long)\n"
2652  " See man %s for detailed description of the options.\n"
2653  "\n", program_name);
2654 
2655  show_help_options(options, "Print help / information / capabilities:",
2656  OPT_EXIT, 0, 0);
2657 
2658  show_help_options(options, "Global options (affect whole program "
2659  "instead of just one file:",
2660  0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2661  if (show_advanced)
2662  show_help_options(options, "Advanced global options:", OPT_EXPERT,
2663  per_file | OPT_EXIT, 0);
2664 
2665  show_help_options(options, "Per-file main options:", 0,
2667  OPT_EXIT, per_file);
2668  if (show_advanced)
2669  show_help_options(options, "Advanced per-file options:",
2670  OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2671 
2672  show_help_options(options, "Video options:",
2674  if (show_advanced)
2675  show_help_options(options, "Advanced Video options:",
2677 
2678  show_help_options(options, "Audio options:",
2680  if (show_advanced)
2681  show_help_options(options, "Advanced Audio options:",
2683  show_help_options(options, "Subtitle options:",
2684  OPT_SUBTITLE, 0, 0);
2685  printf("\n");
2686 
2687  if (show_avoptions) {
2691 #if CONFIG_SWSCALE
2693 #endif
2696  }
2697 }
2698 
2699 void show_usage(void)
2700 {
2701  av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2702  av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2703  av_log(NULL, AV_LOG_INFO, "\n");
2704 }
2705 
2706 enum OptGroup {
2709 };
2710 
2711 static const OptionGroupDef groups[] = {
2712  [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2713  [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2714 };
2715 
2716 static int open_files(OptionGroupList *l, const char *inout,
2717  int (*open_file)(OptionsContext*, const char*))
2718 {
2719  int i, ret;
2720 
2721  for (i = 0; i < l->nb_groups; i++) {
2722  OptionGroup *g = &l->groups[i];
2723  OptionsContext o;
2724 
2725  init_options(&o);
2726  o.g = g;
2727 
2728  ret = parse_optgroup(&o, g);
2729  if (ret < 0) {
2730  av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2731  "%s.\n", inout, g->arg);
2732  return ret;
2733  }
2734 
2735  av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2736  ret = open_file(&o, g->arg);
2737  uninit_options(&o);
2738  if (ret < 0) {
2739  av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2740  inout, g->arg);
2741  return ret;
2742  }
2743  av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2744  }
2745 
2746  return 0;
2747 }
2748 
2749 int ffmpeg_parse_options(int argc, char **argv)
2750 {
2751  OptionParseContext octx;
2752  uint8_t error[128];
2753  int ret;
2754 
2755  memset(&octx, 0, sizeof(octx));
2756 
2757  /* split the commandline into an internal representation */
2758  ret = split_commandline(&octx, argc, argv, options, groups,
2759  FF_ARRAY_ELEMS(groups));
2760  if (ret < 0) {
2761  av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2762  goto fail;
2763  }
2764 
2765  /* apply global options */
2766  ret = parse_optgroup(NULL, &octx.global_opts);
2767  if (ret < 0) {
2768  av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2769  goto fail;
2770  }
2771 
2772  /* open input files */
2773  ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2774  if (ret < 0) {
2775  av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2776  goto fail;
2777  }
2778 
2779  /* open output files */
2780  ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2781  if (ret < 0) {
2782  av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2783  goto fail;
2784  }
2785 
2786 fail:
2787  uninit_parse_context(&octx);
2788  if (ret < 0) {
2789  av_strerror(ret, error, sizeof(error));
2790  av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2791  }
2792  return ret;
2793 }
2794 
2795 static int opt_progress(void *optctx, const char *opt, const char *arg)
2796 {
2797  AVIOContext *avio = NULL;
2798  int ret;
2799 
2800  if (!strcmp(arg, "-"))
2801  arg = "pipe:";
2802  ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2803  if (ret < 0) {
2804  av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2805  arg, av_err2str(ret));
2806  return ret;
2807  }
2808  progress_avio = avio;
2809  return 0;
2810 }
2811 
2812 #define OFFSET(x) offsetof(OptionsContext, x)
2813 const OptionDef options[] = {
2814  /* main options */
2815 #include "cmdutils_common_opts.h"
2816  { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2817  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2818  "force format", "fmt" },
2819  { "y", OPT_BOOL, { &file_overwrite },
2820  "overwrite output files" },
2821  { "n", OPT_BOOL, { &no_file_overwrite },
2822  "never overwrite output files" },
2823  { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2824  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2825  "codec name", "codec" },
2826  { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2827  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2828  "codec name", "codec" },
2829  { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2830  OPT_OUTPUT, { .off = OFFSET(presets) },
2831  "preset name", "preset" },
2832  { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2833  OPT_OUTPUT, { .func_arg = opt_map },
2834  "set input stream mapping",
2835  "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2836  { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2837  "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2838  { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2839  OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2840  "set metadata information of outfile from infile",
2841  "outfile[,metadata]:infile[,metadata]" },
2842  { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2843  OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2844  "set chapters mapping", "input_file_index" },
2845  { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2846  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2847  "record or transcode \"duration\" seconds of audio/video",
2848  "duration" },
2849  { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2850  "record or transcode stop time", "time_stop" },
2851  { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2852  "set the limit file size in bytes", "limit_size" },
2853  { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2854  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2855  "set the start time offset", "time_off" },
2856  { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2857  OPT_INPUT, { .off = OFFSET(accurate_seek) },
2858  "enable/disable accurate seeking with -ss" },
2859  { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2860  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2861  "set the input ts offset", "time_off" },
2862  { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2863  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2864  "set the input ts scale", "scale" },
2865  { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
2866  "set the recording timestamp ('now' to set the current time)", "time" },
2867  { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2868  "add metadata", "string=string" },
2869  { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2870  OPT_OUTPUT, { .func_arg = opt_data_frames },
2871  "set the number of data frames to output", "number" },
2872  { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2873  "add timings for benchmarking" },
2874  { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2875  "add timings for each task" },
2876  { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2877  "write program-readable progress information", "url" },
2878  { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2879  "enable or disable interaction on standard input" },
2880  { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2881  "set max runtime in seconds", "limit" },
2882  { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2883  "dump each input packet" },
2884  { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2885  "when dumping packets, also dump the payload" },
2886  { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2887  OPT_INPUT, { .off = OFFSET(rate_emu) },
2888  "read input at native frame rate", "" },
2889  { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2890  "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2891  " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2892  { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2893  "video sync method", "" },
2894  { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
2895  "frame drop threshold", "" },
2896  { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2897  "audio sync method", "" },
2898  { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2899  "audio drift threshold", "threshold" },
2900  { "copyts", OPT_BOOL | OPT_EXPERT, { &copy_ts },
2901  "copy timestamps" },
2902  { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
2903  "shift input timestamps to start at 0 when using copyts" },
2904  { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { &copy_tb },
2905  "copy input stream time base when stream copying", "mode" },
2906  { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2907  OPT_OUTPUT, { .off = OFFSET(shortest) },
2908  "finish encoding within shortest input" },
2909  { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
2910  OPT_OUTPUT, { .off = OFFSET(apad) },
2911  "audio pad", "" },
2912  { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2913  "timestamp discontinuity delta threshold", "threshold" },
2914  { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2915  "timestamp error delta threshold", "threshold" },
2916  { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2917  "exit on error", "error" },
2918  { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2919  OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2920  "copy initial non-keyframes" },
2921  { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2922  "copy or discard frames before start time" },
2923  { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2924  "set the number of frames to output", "number" },
2925  { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2926  OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
2927  "force codec tag/fourcc", "fourcc/tag" },
2928  { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2929  OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2930  "use fixed quality scale (VBR)", "q" },
2931  { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2932  OPT_OUTPUT, { .func_arg = opt_qscale },
2933  "use fixed quality scale (VBR)", "q" },
2934  { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2935  "set profile", "profile" },
2936  { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2937  "set stream filtergraph", "filter_graph" },
2938  { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2939  "read stream filtergraph description from a file", "filename" },
2940  { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
2941  "reinit filtergraph on input parameter changes", "" },
2942  { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2943  "create a complex filtergraph", "graph_description" },
2944  { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2945  "create a complex filtergraph", "graph_description" },
2946  { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2947  "read complex filtergraph description from a file", "filename" },
2948  { "stats", OPT_BOOL, { &print_stats },
2949  "print progress report during encoding", },
2950  { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2951  OPT_OUTPUT, { .func_arg = opt_attach },
2952  "add an attachment to the output file", "filename" },
2953  { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2954  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2955  "extract an attachment into a file", "filename" },
2956  { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2957  "print timestamp debugging info" },
2958  { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
2959  "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
2960  { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
2961  OPT_INPUT, { .off = OFFSET(discard) },
2962  "discard", "" },
2963  { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
2964  OPT_OUTPUT, { .off = OFFSET(disposition) },
2965  "disposition", "" },
2966  { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
2967  { .off = OFFSET(thread_queue_size) },
2968  "set the maximum number of queued packets from the demuxer" },
2969 
2970  /* video options */
2971  { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2972  "set the number of video frames to output", "number" },
2973  { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2974  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2975  "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2977  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2978  "set frame size (WxH or abbreviation)", "size" },
2979  { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2980  OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2981  "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2982  { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2983  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2984  "set pixel format", "format" },
2985  { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2986  "set the number of bits per raw sample", "number" },
2987  { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2988  "deprecated use -g 1" },
2990  "disable video" },
2991  { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2992  OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2993  "rate control override for specific intervals", "override" },
2994  { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2995  OPT_OUTPUT, { .func_arg = opt_video_codec },
2996  "force video codec ('copy' to copy stream)", "codec" },
2997  { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2998  "Removed" },
2999  { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3000  "Removed" },
3001  { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3002  "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3003  { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3004  "select the pass number (1 to 3)", "n" },
3005  { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3006  OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3007  "select two pass log file name prefix", "prefix" },
3008  { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3009  "this option is deprecated, use the yadif filter instead" },
3010  { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3011  "calculate PSNR of compressed frames" },
3012  { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
3013  "dump video coding statistics to file" },
3014  { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
3015  "dump video coding statistics to file", "file" },
3016  { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3017  "set video filters", "filter_graph" },
3018  { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3019  OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3020  "specify intra matrix coeffs", "matrix" },
3021  { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3022  OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3023  "specify inter matrix coeffs", "matrix" },
3024  { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3025  OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3026  "specify intra matrix coeffs", "matrix" },
3027  { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3028  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3029  "top=1/bottom=0/auto=-1 field first", "" },
3030  { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3031  OPT_OUTPUT, { .func_arg = opt_old2new },
3032  "force video tag/fourcc", "fourcc/tag" },
3033  { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3034  "show QP histogram" },
3035  { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3036  OPT_OUTPUT, { .off = OFFSET(force_fps) },
3037  "force the selected framerate, disable the best supported framerate selection" },
3038  { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3039  OPT_OUTPUT, { .func_arg = opt_streamid },
3040  "set the value of an outfile streamid", "streamIndex:value" },
3041  { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3042  OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3043  "force key frames at specified timestamps", "timestamps" },
3044  { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3045  "audio bitrate (please use -b:a)", "bitrate" },
3046  { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3047  "video bitrate (please use -b:v)", "bitrate" },
3048  { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3049  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3050  "use HW accelerated decoding", "hwaccel name" },
3051  { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3052  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3053  "select a device for HW acceleration" "devicename" },
3054 #if HAVE_VDPAU_X11
3055  { "vdpau_api_ver", HAS_ARG | OPT_INT | OPT_EXPERT, { &vdpau_api_ver }, "" },
3056 #endif
3057 
3058  /* audio options */
3059  { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3060  "set the number of audio frames to output", "number" },
3061  { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3062  "set audio quality (codec-specific)", "quality", },
3063  { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3064  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3065  "set audio sampling rate (in Hz)", "rate" },
3066  { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3067  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3068  "set number of audio channels", "channels" },
3070  "disable audio" },
3071  { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3072  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3073  "force audio codec ('copy' to copy stream)", "codec" },
3074  { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3075  OPT_OUTPUT, { .func_arg = opt_old2new },
3076  "force audio tag/fourcc", "fourcc/tag" },
3077  { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3078  "change audio volume (256=normal)" , "volume" },
3079  { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3081  "set sample format", "format" },
3082  { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3083  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3084  "set channel layout", "layout" },
3085  { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3086  "set audio filters", "filter_graph" },
3087  { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3088  "set the maximum number of channels to try to guess the channel layout" },
3089 
3090  /* subtitle options */
3092  "disable subtitle" },
3093  { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3094  "force subtitle codec ('copy' to copy stream)", "codec" },
3095  { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3096  , "force subtitle tag/fourcc", "fourcc/tag" },
3097  { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3098  "fix subtitles duration" },
3099  { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3100  "set canvas size (WxH or abbreviation)", "size" },
3101 
3102  /* grab options */
3103  { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3104  "deprecated, use -channel", "channel" },
3105  { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3106  "deprecated, use -standard", "standard" },
3107  { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3108 
3109  /* muxer options */
3110  { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3111  "set the maximum demux-decode delay", "seconds" },
3112  { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3113  "set the initial demux-decode delay", "seconds" },
3114  { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3115  "override the options from ffserver", "" },
3116  { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { opt_sdp_file },
3117  "specify a file in which to print sdp information", "file" },
3118 
3119  { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3120  "A comma-separated list of bitstream filters", "bitstream_filters" },
3121  { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3122  "deprecated", "audio bitstream_filters" },
3123  { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3124  "deprecated", "video bitstream_filters" },
3125 
3126  { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3127  "set the audio options to the indicated preset", "preset" },
3128  { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3129  "set the video options to the indicated preset", "preset" },
3130  { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3131  "set the subtitle options to the indicated preset", "preset" },
3132  { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3133  "set options from indicated preset file", "filename" },
3134  /* data codec support */
3135  { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3136  "force data codec ('copy' to copy stream)", "codec" },
3137  { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3138  "disable data" },
3139 
3140  { NULL, },
3141 };
unsigned int nb_chapters
Number of chapters in AVChapter array.
Definition: avformat.h:1424
int avio_open(AVIOContext **s, const char *url, int flags)
Create and initialize a AVIOContext for accessing the resource indicated by url.
Definition: aviobuf.c:902
int parse_optgroup(void *optctx, OptionGroup *g)
Parse an options group and write results into optctx.
Definition: cmdutils.c:400
char * vstats_filename
Definition: ffmpeg_opt.c:79
int av_parse_ratio(AVRational *q, const char *str, int max, int log_offset, void *log_ctx)
Parse str and store the parsed ratio in q.
Definition: parseutils.c:44
int nb_dump_attachment
Definition: ffmpeg.h:119
int guess_input_channel_layout(InputStream *ist)
Definition: ffmpeg.c:1812
void show_usage(void)
Definition: ffmpeg_opt.c:2699
int nb_metadata
Definition: ffmpeg.h:155
int nb_streamid_map
Definition: ffmpeg.h:152
#define NULL
Definition: coverity.c:32
const char const char void * val
Definition: avisynth_c.h:672
int audio_sync_method
Definition: ffmpeg_opt.c:87
AVDictionary * resample_opts
Definition: cmdutils.h:279
int keep_pix_fmt
Definition: ffmpeg.h:439
const char * s
Definition: avisynth_c.h:669
Bytestream IO Context.
Definition: avio.h:68
float mux_preload
Definition: ffmpeg.h:141
#define OPT_EXPERT
Definition: cmdutils.h:163
int start_at_zero
Definition: ffmpeg_opt.c:96
int64_t recording_time
desired length of the resulting file in microseconds == AV_TIME_BASE units
Definition: ffmpeg.h:457
void term_init(void)
Definition: ffmpeg.c:327
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:281
static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
Definition: ffmpeg_opt.c:1059
int nb_outputs
Definition: ffmpeg.h:241
int copy_tb
Definition: ffmpeg_opt.c:97
AVDictionary * swr_opts
Definition: ffmpeg.h:427
int qp_hist
Definition: ffmpeg_opt.c:101
AVDictionary * swr_opts
Definition: cmdutils.h:281
int resample_channels
Definition: ffmpeg.h:284
enum AVPixelFormat choose_pixel_fmt(AVStream *st, AVCodecContext *avctx, AVCodec *codec, enum AVPixelFormat target)
Definition: ffmpeg_filter.c:40
#define av_realloc_f(p, o, n)
int av_parse_video_rate(AVRational *rate, const char *arg)
Parse str and store the detected values in *rate.
Definition: parseutils.c:169
void term_exit(void)
Definition: ffmpeg.c:306
int stream_copy
Definition: ffmpeg.h:433
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: utils.c:2919
static int opt_data_frames(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2402
int do_benchmark
Definition: ffmpeg_opt.c:91
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
Definition: avformat.h:1473
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1112
AVOption.
Definition: opt.h:255
AVRational frame_rate
Definition: ffmpeg.h:399
int audio_channels
Definition: rtp.c:40
int av_parse_video_size(int *width_ptr, int *height_ptr, const char *str)
Parse str and put in width_ptr and height_ptr the detected values.
Definition: parseutils.c:138
static void init_output_filter(OutputFilter *ofilter, OptionsContext *o, AVFormatContext *oc)
Definition: ffmpeg_opt.c:1700
char * filters
filtergraph associated to the -filter option
Definition: ffmpeg.h:422
static AVInputFormat * file_iformat
Definition: ffplay.c:302
#define OPT_VIDEO
Definition: cmdutils.h:165
#define CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:735
int data_disable
Definition: ffmpeg.h:148
float mux_max_delay
Definition: ffmpeg.h:142
int accurate_seek
Definition: ffmpeg.h:347
int * streamid_map
Definition: ffmpeg.h:151
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:181
int video_sync_method
Definition: ffmpeg_opt.c:88
Main libavfilter public API header.
int nb_stream_maps
Definition: ffmpeg.h:127
static void assert_file_overwrite(const char *filename)
Definition: ffmpeg_opt.c:733
int ostream_idx
Definition: ffmpeg.h:87
#define AV_DICT_DONT_OVERWRITE
Don't overwrite existing entries.
Definition: dict.h:81
static int input_sync
Definition: ffmpeg_opt.c:111
const char * g
Definition: vf_curves.c:108
#define CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:734
int split_commandline(OptionParseContext *octx, int argc, char *argv[], const OptionDef *options, const OptionGroupDef *groups, int nb_groups)
Split the commandline into an intermediate form convenient for further processing.
Definition: cmdutils.c:719
AVRational framerate
Definition: ffmpeg.h:274
void choose_sample_fmt(AVStream *st, AVCodec *codec)
Definition: ffmpeg_filter.c:78
void avfilter_inout_free(AVFilterInOut **inout)
Free the supplied list of AVFilterInOut and set *inout to NULL.
Definition: graphparser.c:184
enum AVCodecID video_codec
default video codec
Definition: avformat.h:489
int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
Check if the given stream matches a stream specifier.
Definition: cmdutils.c:1971
#define OPT_AUDIO
Definition: cmdutils.h:166
AVFilterInOut * out_tmp
Definition: ffmpeg.h:228
enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx)
Get the type of an AVFilterPad.
Definition: avfilter.c:995
int qscale
Definition: avcodec.h:689
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:879
int num
numerator
Definition: rational.h:44
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:290
int index
stream index in AVFormatContext
Definition: avformat.h:808
int nb_frame_pix_fmts
Definition: ffmpeg.h:108
#define AVIO_FLAG_READ
read-only
Definition: avio.h:368
int do_deinterlace
Definition: ffmpeg_opt.c:90
static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2534
#define AVIO_FLAG_WRITE
write-only
Definition: avio.h:369
static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
Definition: ffmpeg_opt.c:1650
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
Definition: avcodec.h:1621
#define AV_CODEC_PROP_TEXT_SUB
Subtitle codec is text based.
Definition: avcodec.h:618
AVBitStreamFilterContext * bitstream_filters
Definition: ffmpeg.h:390
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1442
external API header
const char * arg
Definition: cmdutils.h:272
static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2605
#define OPT_DATA
Definition: cmdutils.h:172
static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
Definition: ffmpeg_opt.c:1607
enum AVMediaType type
Definition: avcodec.h:3186
#define FF_ARRAY_ELEMS(a)
static int file_overwrite
Definition: ffmpeg_opt.c:108
static OutputStream * new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
Definition: ffmpeg_opt.c:1076
discard all
Definition: avcodec.h:667
int64_t input_ts_offset
Definition: ffmpeg.h:338
const AVClass * sws_get_class(void)
Get the AVClass for swsContext.
Definition: options.c:90
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2725
int nb_input_streams
Definition: ffmpeg.c:137
static int audio_disable
Definition: ffplay.c:311
const char * name
Definition: ffmpeg.h:69
AVDictionary * metadata
Definition: avformat.h:1195
static const char * audio_codec_name
Definition: ffplay.c:332
#define OPT_DOUBLE
Definition: cmdutils.h:180
enum AVCodecID subtitle_codec_id
Forced subtitle codec_id.
Definition: avformat.h:1393
#define OPT_FLOAT
Definition: cmdutils.h:168
AVCodec.
Definition: avcodec.h:3173
#define VSYNC_VFR
Definition: ffmpeg.h:54
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1100
int avcodec_copy_context(AVCodecContext *dest, const AVCodecContext *src)
Copy the settings of the source AVCodecContext into the destination AVCodecContext.
Definition: options.c:180
AVDictionary * filter_codec_opts(AVDictionary *opts, enum AVCodecID codec_id, AVFormatContext *s, AVStream *st, AVCodec *codec)
Filter out options for given codec.
Definition: cmdutils.c:1979
int64_t start_time
start time in microseconds == AV_TIME_BASE units
Definition: ffmpeg.h:458
void av_format_set_subtitle_codec(AVFormatContext *s, AVCodec *c)
int index
Definition: ffmpeg.h:232
static int opt_preset(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2428
Definition: ftp.c:32
SpecifierOpt * frame_pix_fmts
Definition: ffmpeg.h:107
static int opt_data_codec(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:216
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1367
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
#define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)
Definition: ffmpeg_opt.c:44
void uninit_parse_context(OptionParseContext *octx)
Free all allocated memory in an OptionParseContext.
Definition: cmdutils.c:692
static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2599
Format I/O context.
Definition: avformat.h:1226
const AVClass * avcodec_get_class(void)
Get the AVClass for AVCodecContext.
Definition: options.c:256
int avio_check(const char *url, int flags)
Return AVIO_FLAG_* access flags corresponding to the access permissions of the resource in url...
Definition: avio.c:407
enum HWAccelID id
Definition: ffmpeg.h:71
#define CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
Definition: avcodec.h:744
uint64_t av_get_channel_layout(const char *name)
Return a channel layout id that matches name, or 0 if no match is found.
void av_codec_set_chroma_intra_matrix(AVCodecContext *avctx, uint16_t *val)
static const uint8_t frame_sizes[]
Definition: rtpdec_qcelp.c:24
static int do_psnr
Definition: ffmpeg_opt.c:110
char * logfile_prefix
Definition: ffmpeg.h:417
#define AVFMT_FLAG_NONBLOCK
Do not block when reading packets from input.
Definition: avformat.h:1340
AVFilterPad * output_pads
array of output pads
Definition: avfilter.h:647
int vdpau_init(AVCodecContext *s)
Definition: ffmpeg_vdpau.c:352
int user_set_discard
Definition: ffmpeg.h:248
static int64_t start_time
Definition: ffplay.c:319
int copy_initial_nonkeyframes
Definition: ffmpeg.h:435
if()
Definition: avfilter.c:975
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1991
int flags
can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_RAWPICTURE, AVFMT_GLOBALHEADER, AVFMT_NOTIMESTAMPS, AVFMT_VARIABLE_FPS, AVFMT_NODIMENSIONS, AVFMT_NOSTREAMS, AVFMT_ALLOW_FLUSH, AVFMT_TS_NONSTRICT
Definition: avformat.h:497
uint8_t
static int nb_streams
Definition: ffprobe.c:216
#define av_malloc(s)
Opaque data information usually continuous.
Definition: avutil.h:196
int opt_default(void *optctx, const char *opt, const char *arg)
Fallback for options that are not explicitly handled, these will be parsed through AVOptions...
Definition: cmdutils.c:519
#define OPT_OUTPUT
Definition: cmdutils.h:182
AVOptions.
#define HAS_ARG
Definition: cmdutils.h:161
static int open_input_file(OptionsContext *o, const char *filename)
Definition: ffmpeg_opt.c:794
static const OptionGroupDef groups[]
Definition: ffmpeg_opt.c:2711
static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:386
AVDictionary * opts
Definition: ffmpeg.h:455
#define CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:756
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:67
uint16_t * chroma_intra_matrix
custom intra quantization matrix Code outside libavcodec should access this field using av_codec_g/se...
Definition: avcodec.h:3122
int id
unique ID to identify the chapter
Definition: avformat.h:1192
static int opt_vsync(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2540
#define AVCONV_DATADIR
Definition: config.h:8
int id
Format-specific stream ID.
Definition: avformat.h:814
#define OPT_OFFSET
Definition: cmdutils.h:175
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1353
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:3663
int nb_max_frames
Definition: ffmpeg.h:157
int shortest
Definition: ffmpeg.h:461
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1294
static int opt_vstats(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2376
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:107
int channel_idx
Definition: ffmpeg.h:86
const char * name
Definition: avcodec.h:5067
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:618
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:39
int nb_streams
Definition: ffmpeg.h:343
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1337
int sync_file_index
Definition: ffmpeg.h:80
AVDictionary * resample_opts
Definition: ffmpeg.h:428
list ifile
Definition: normalize.py:6
uint32_t tag
Definition: movenc.c:1332
#define OPT_SPEC
Definition: cmdutils.h:176
int nb_input_files
Definition: ffmpeg.c:139
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:191
int resample_sample_rate
Definition: ffmpeg.h:283
const AVClass * avformat_get_class(void)
Get the AVClass for AVFormatContext.
Definition: options.c:129
int print_stats
Definition: ffmpeg_opt.c:100
void show_help_options(const OptionDef *options, const char *msg, int req_flags, int rej_flags, int alt_flags)
Print help for all options matching specified flags.
Definition: cmdutils.c:162
AVCodec * dec
Definition: ffmpeg.h:254
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:177
const OptionDef options[]
Definition: ffmpeg_opt.c:2813
int top_field_first
Definition: ffmpeg.h:275
int nb_output_streams
Definition: ffmpeg.c:142
int file_index
Definition: ffmpeg.h:245
void av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:208
struct AVBitStreamFilterContext * next
Definition: avcodec.h:5062
int resample_pix_fmt
Definition: ffmpeg.h:280
int resample_height
Definition: ffmpeg.h:278
enum AVCodecID video_codec_id
Forced video codec_id.
Definition: avformat.h:1381
int64_t filter_in_rescale_delta_last
Definition: ffmpeg.h:268
#define av_log(a,...)
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
Definition: opt.h:285
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:537
static int opt_video_codec(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:204
float quality_factor
Definition: avcodec.h:690
static int opt_qscale(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2501
unsigned m
Definition: audioconvert.c:187
struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1245
AVDictionary ** setup_find_stream_info_opts(AVFormatContext *s, AVDictionary *codec_opts)
Setup AVCodecContext options for avformat_find_stream_info().
Definition: cmdutils.c:2036
AVCodec * avcodec_find_encoder_by_name(const char *name)
Find a registered encoder with the specified name.
Definition: utils.c:2924
AVDictionary * format_opts
Definition: cmdutils.c:66
static OutputStream * new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
Definition: ffmpeg_opt.c:1557
int avformat_alloc_output_context2(AVFormatContext **ctx, AVOutputFormat *oformat, const char *format_name, const char *filename)
Allocate an AVFormatContext for an output format.
Definition: mux.c:118
#define OPT_SUBTITLE
Definition: cmdutils.h:169
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:147
void av_dump_format(AVFormatContext *ic, int index, const char *url, int is_output)
Print detailed information about the input or output format, such as duration, bitrate, streams, container, programs, metadata, side data, codec and time base.
Definition: dump.c:428
enum AVCodecID id
Definition: avcodec.h:3187
int rate_emu
Definition: ffmpeg.h:346
int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:213
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: avcodec.h:102
static int opt_profile(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2516
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:175
#define AV_DICT_MATCH_CASE
Only get an entry with exact-case key match.
Definition: dict.h:71
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1435
static int configure_complex_filters(void)
Definition: ffmpeg_opt.c:1746
enum AVPixelFormat hwaccel_pix_fmt
Definition: ffmpeg.h:320
FilterGraph ** filtergraphs
Definition: ffmpeg.c:146
const AVIOInterruptCB int_cb
Definition: ffmpeg.c:423
static int open_files(OptionGroupList *l, const char *inout, int(*open_file)(OptionsContext *, const char *))
Definition: ffmpeg_opt.c:2716
static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:210
#define AV_OPT_FLAG_FILTERING_PARAM
a generic parameter which can be set by the user for filtering
Definition: opt.h:302
int64_t start_time
Definition: ffmpeg.h:94
static int opt_video_channel(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:186
#define AVERROR(e)
Definition: error.h:43
int64_t last_mux_dts
Definition: ffmpeg.h:389
static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:517
void av_format_set_data_codec(AVFormatContext *s, AVCodec *c)
int ofile_idx
Definition: ffmpeg.h:87
int64_t sws_flags
Definition: ffmpeg.h:425
int avio_close(AVIOContext *s)
Close the resource accessed by the AVIOContext s and free it.
Definition: aviobuf.c:924
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:196
AudioChannelMap * audio_channel_maps
Definition: ffmpeg.h:128
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:194
int debug_ts
Definition: ffmpeg_opt.c:98
const char * arg
Definition: jacosubdec.c:66
int flags
CODEC_FLAG_*.
Definition: avcodec.h:1333
const char * name
Definition: cmdutils.h:159
static int opt_bitrate(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2485
int parse_option(void *optctx, const char *opt, const char *arg, const OptionDef *options)
Parse one given option.
Definition: cmdutils.c:336
AVChapter ** chapters
Definition: avformat.h:1425
Definition: graph2dot.c:48
static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
Parse a metadata specifier passed as 'arg' parameter.
Definition: ffmpeg_opt.c:400
#define CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:710
simple assert() macros that are a bit more flexible than ISO C assert().
const char * name
Name of the codec implementation.
Definition: avcodec.h:3180
static int opt_old2new(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2476
void remove_avoptions(AVDictionary **a, AVDictionary *b)
Definition: ffmpeg.c:545
int video_disable
Definition: ffmpeg.h:145
static int opt_sameq(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:177
HW acceleration through VDA, data[3] contains a CVPixelBufferRef.
Definition: pixfmt.h:237
int flags
Definition: cmdutils.h:160
static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
Definition: ffmpeg_opt.c:427
enum AVCodecID codec_id
Definition: mov_chan.c:433
int force_fps
Definition: ffmpeg.h:400
GLsizei count
Definition: opengl_enc.c:109
#define FFMAX(a, b)
Definition: common.h:79
static void uninit_options(OptionsContext *o)
Definition: ffmpeg_opt.c:114
Libavcodec external API header.
StreamMap * stream_maps
Definition: ffmpeg.h:126
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:83
char * av_get_token(const char **buf, const char *term)
Unescape the given string until a non escaped terminating char, and return the token corresponding to...
Definition: avstring.c:149
uint64_t limit_filesize
Definition: ffmpeg.h:140
const char * format
Definition: ffmpeg.h:95
int av_codec_get_lowres(const AVCodecContext *avctx)
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:2877
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2044
#define pass
Definition: fft_template.c:509
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:528
AVCodecContext * codec
Codec context associated with this stream.
Definition: avformat.h:826
OutputFilter * filter
Definition: ffmpeg.h:420
int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id, int std_compliance)
Test if the given container can store a codec.
Definition: utils.c:4097
int ffmpeg_parse_options(int argc, char **argv)
Definition: ffmpeg_opt.c:2749
int props
Codec properties, a combination of AV_CODEC_PROP_* flags.
Definition: avcodec.h:574
AVRational frame_aspect_ratio
Definition: ffmpeg.h:403
static AVDictionary * strip_specifiers(AVDictionary *dict)
Definition: ffmpeg_opt.c:160
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:113
const AVOption * av_opt_find(void *obj, const char *name, const char *unit, int opt_flags, int search_flags)
Look for an option in an object.
Definition: opt.c:1484
static const char * subtitle_codec_name
Definition: ffplay.c:333
static int subtitle_disable
Definition: ffplay.c:313
int file_index
Definition: ffmpeg.h:78
int nb_audio_channel_maps
Definition: ffmpeg.h:129
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1282
int nb_attachments
Definition: ffmpeg.h:134
OptionGroup * groups
Definition: cmdutils.h:291
AVInputFormat * av_find_input_format(const char *short_name)
Find AVInputFormat based on the short name of the input format.
Definition: format.c:160
static int opt_video_filters(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2528
int nb_output_files
Definition: ffmpeg.c:144
int rc_override_count
ratecontrol override, see RcOverride
Definition: avcodec.h:2309
size_t off
Definition: cmdutils.h:186
char * linklabel
Definition: ffmpeg.h:82
option
Definition: libwebpenc.c:337
int void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:197
audio channel layout utility functions
char filename[1024]
input or output filename
Definition: avformat.h:1302
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:247
#define FFMIN(a, b)
Definition: common.h:81
enum AVCodecID audio_codec_id
Forced audio codec_id.
Definition: avformat.h:1387
SpecifierOpt * audio_channels
Definition: ffmpeg.h:99
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:213
static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
Definition: ffmpeg_opt.c:576
#define VSYNC_AUTO
Definition: ffmpeg.h:51
int av_get_exact_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:3224
int nb_audio_sample_rate
Definition: ffmpeg.h:102
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:147
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:602
static int opt_progress(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2795
int exit_on_error
Definition: ffmpeg_opt.c:99
int metadata_chapters_manual
Definition: ffmpeg.h:132
enum AVCodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name, const char *filename, const char *mime_type, enum AVMediaType type)
Guess the codec ID based upon muxer and filename.
Definition: format.c:129
struct OutputStream * ost
Definition: ffmpeg.h:223
ret
Definition: avfilter.c:974
int accurate_seek
Definition: ffmpeg.h:113
int width
picture width / height.
Definition: avcodec.h:1412
AVBitStreamFilterContext * av_bitstream_filter_init(const char *name)
Create and initialize a bitstream filter context given a bitstream filter name.
static int open_output_file(OptionsContext *o, const char *filename)
Definition: ffmpeg_opt.c:1757
char * apad
Definition: ffmpeg.h:430
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:109
SpecifierOpt * audio_sample_rate
Definition: ffmpeg.h:101
char * sdp_filename
Definition: ffmpeg_opt.c:80
#define AVFMT_GLOBALHEADER
Format wants global header.
Definition: avformat.h:436
const char * name
Definition: avformat.h:478
int dxva2_init(AVCodecContext *s)
Definition: ffmpeg_dxva2.c:598
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:119
SpecifierOpt * dump_attachment
Definition: ffmpeg.h:118
A list of option groups that all have the same group type (e.g.
Definition: cmdutils.h:288
int copy_ts
Definition: ffmpeg_opt.c:95
#define OPT_EXIT
Definition: cmdutils.h:171
static AVCodec * find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
Definition: ffmpeg_opt.c:532
int nb_filtergraphs
Definition: ffmpeg.c:147
int start_frame
Definition: avcodec.h:687
float frame_drop_threshold
Definition: ffmpeg_opt.c:89
SpecifierOpt * metadata_map
Definition: ffmpeg.h:182
static int open_file(AVFormatContext *avf, unsigned fileno)
Definition: concatdec.c:278
#define OPT_INT64
Definition: cmdutils.h:170
#define AV_DICT_APPEND
If the entry already exists, append to it.
Definition: dict.h:82
int64_t max_frames
Definition: ffmpeg.h:393
#define AV_RL32
Definition: intreadwrite.h:146
char * specifier
stream/chapter/program/...
Definition: cmdutils.h:148
float u
int audio_channels_mapped
Definition: ffmpeg.h:415
int n
Definition: avisynth_c.h:589
AVDictionary * metadata
Definition: avformat.h:881
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:193
Opaque data information usually sparse.
Definition: avutil.h:198
static void init_options(OptionsContext *o)
Definition: ffmpeg_opt.c:146
void av_format_set_audio_codec(AVFormatContext *s, AVCodec *c)
const AVClass * swr_get_class(void)
Get the AVClass for SwrContext.
Definition: options.c:143
int opt_timelimit(void *optctx, const char *opt, const char *arg)
Limit the execution time.
Definition: cmdutils.c:1004
int av_opt_set_dict2(void *obj, AVDictionary **options, int search_flags)
Set all the options from a given dictionary on an object.
Definition: opt.c:1454
SpecifierOpt * frame_sizes
Definition: ffmpeg.h:105
int stream_idx
Definition: ffmpeg.h:86
const AVCodecDescriptor * avcodec_descriptor_get_by_name(const char *name)
Definition: codec_desc.c:2896
AVFilterContext * filter_ctx
filter context associated to this input/output
Definition: avfilter.h:1354
int do_hex_dump
Definition: ffmpeg_opt.c:93
RcOverride * rc_override
Definition: avcodec.h:2310
#define AV_DISPOSITION_ATTACHED_PIC
The stream is stored in the file as an attached picture/"cover art" (e.g.
Definition: avformat.h:784
void exit_program(int ret)
Wraps exit with a program-specific cleanup routine.
Definition: cmdutils.c:121
int do_pkt_dump
Definition: ffmpeg_opt.c:94
uint8_t * str
Definition: cmdutils.h:150
Stream structure.
Definition: avformat.h:807
const AVClass * avfilter_get_class(void)
Definition: avfilter.c:1176
A linked-list of the inputs/outputs of the filter chain.
Definition: avfilter.h:1349
int64_t end
chapter start/end time in time_base units
Definition: avformat.h:1194
int av_dict_parse_string(AVDictionary **pm, const char *str, const char *key_val_sep, const char *pairs_sep, int flags)
Parse the key/value pairs list and add the parsed entries to a dictionary.
Definition: dict.c:171
int fix_sub_duration
Definition: ffmpeg.h:287
int av_opt_get_int(void *obj, const char *name, int search_flags, int64_t *out_val)
Definition: opt.c:822
#define VSYNC_DROP
Definition: ffmpeg.h:56
int64_t recording_time
Definition: ffmpeg.h:342
int do_benchmark_all
Definition: ffmpeg_opt.c:92
Definition: ffmpeg.h:68
SpecifierOpt * frame_rates
Definition: ffmpeg.h:103
#define AV_LOG_INFO
Standard information.
Definition: log.h:186
int frame_size
Definition: mxfenc.c:1618
int file_idx
Definition: ffmpeg.h:86
int ost_index
Definition: ffmpeg.h:456
struct InputStream * sync_ist
Definition: ffmpeg.h:383
enum AVMediaType codec_type
Definition: avcodec.h:1247
double ts_scale
Definition: ffmpeg.h:270
int64_t recording_time
Definition: ffmpeg.h:138
int chapters_input_file
Definition: ffmpeg.h:136
int64_t stop_time
Definition: ffmpeg.h:139
enum AVCodecID codec_id
Definition: avcodec.h:1256
static int intra_only
Definition: ffmpeg_opt.c:107
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:253
char * av_strdup(const char *s)
Duplicate the string s.
Definition: mem.c:265
int stdin_interaction
Definition: ffmpeg_opt.c:102
int sample_rate
samples per second
Definition: avcodec.h:1983
AVIOContext * pb
I/O context.
Definition: avformat.h:1268
#define SET_DICT(type, meta, context, index)
int ist_index
Definition: ffmpeg.h:337
const char * graph_desc
Definition: ffmpeg.h:233
int guess_layout_max
Definition: ffmpeg.h:276
int64_t start_time
Definition: ffmpeg.h:341
static int override_ffserver
Definition: ffmpeg_opt.c:112
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:155
#define AV_OPT_FLAG_VIDEO_PARAM
Definition: opt.h:291
main external API structure.
Definition: avcodec.h:1239
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: utils.c:2938
int rate_emu
Definition: ffmpeg.h:112
int av_filename_number_test(const char *filename)
Check whether filename actually is a numbered sequence generator.
Definition: utils.c:257
void av_format_set_video_codec(AVFormatContext *s, AVCodec *c)
int metadata_streams_manual
Definition: ffmpeg.h:131
const char * attachment_filename
Definition: ffmpeg.h:434
int configure_output_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:1271
a very simple circular buffer FIFO implementation
#define AV_CODEC_PROP_BITMAP_SUB
Subtitle codec is bitmap based Decoded AVSubtitle data can be read from the AVSubtitleRect->pict fiel...
Definition: avcodec.h:613
void assert_avoptions(AVDictionary *m)
Definition: ffmpeg.c:554
AVCodecContext * enc_ctx
Definition: ffmpeg.h:391
int audio_disable
Definition: ffmpeg.h:146
void * buf
Definition: avisynth_c.h:595
int64_t input_ts_offset
Definition: ffmpeg.h:111
GLint GLenum type
Definition: opengl_enc.c:105
int extradata_size
Definition: avcodec.h:1354
float audio_drift_threshold
Definition: ffmpeg_opt.c:82
void show_help_default(const char *opt, const char *arg)
Per-fftool specific help handler.
Definition: ffmpeg_opt.c:2631
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:69
struct AVBitStreamFilter * filter
Definition: avcodec.h:5060
uint16_t * intra_matrix
custom intra quantization matrix
Definition: avcodec.h:1785
AVCodecContext * dec_ctx
Definition: ffmpeg.h:253
static int opt_map_channel(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:327
FILE * get_preset_file(char *filename, size_t filename_size, const char *preset_name, int is_path, const char *codec_name)
Get a file corresponding to a preset file.
Definition: cmdutils.c:1921
AVStream * st
Definition: ffmpeg.h:246
int * audio_channels_map
Definition: ffmpeg.h:414
#define VSYNC_PASSTHROUGH
Definition: ffmpeg.h:52
Describe the class of an AVClass context structure.
Definition: log.h:66
int configure_filtergraph(FilterGraph *fg)
#define NTSC
Definition: bktr.c:67
OutputStream ** output_streams
Definition: ffmpeg.c:141
int index
Definition: gxfenc.c:89
int pad_idx
index of the filt_ctx pad to use for linking
Definition: avfilter.h:1357
static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2617
static char * get_ost_filters(OptionsContext *o, AVFormatContext *oc, OutputStream *ost)
Definition: ffmpeg_opt.c:1265
enum AVCodecID subtitle_codec
default subtitle codec
Definition: avformat.h:490
rational number numerator/denominator
Definition: rational.h:43
int file_index
Definition: ffmpeg.h:375
int metadata_global_manual
Definition: ffmpeg.h:130
HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface.
Definition: pixfmt.h:216
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:286
int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration)
Parse a string specifying a time and return its corresponding value as a number of microseconds...
Definition: cmdutils.c:150
void * grow_array(void *array, int elem_size, int *size, int new_size)
Realloc array to hold new_size elements of elem_size.
Definition: cmdutils.c:2056
#define OPT_STRING
Definition: cmdutils.h:164
char * disposition
Definition: ffmpeg.h:437
enum AVSampleFormat av_get_sample_fmt(const char *name)
Return a sample format corresponding to name, or AV_SAMPLE_FMT_NONE on error.
Definition: samplefmt.c:54
AVMediaType
Definition: avutil.h:192
static OutputStream * new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
Definition: ffmpeg_opt.c:1463
int avio_open2(AVIOContext **s, const char *url, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options)
Create and initialize a AVIOContext for accessing the resource indicated by url.
Definition: aviobuf.c:907
AVDictionary * decoder_opts
Definition: ffmpeg.h:273
int shortest
Definition: ffmpeg.h:143
#define MAX_STREAMS
Definition: ffmpeg.h:58
const char * name
Name of the codec described by this descriptor.
Definition: avcodec.h:566
#define snprintf
Definition: snprintf.h:34
int av_opt_eval_int(void *obj, const AVOption *o, const char *val, int *int_out)
int vdpau_api_ver
Definition: ffmpeg_vdpau.c:62
int64_t ts_offset
Definition: ffmpeg.h:339
char * filters_script
filtergraph script associated to the -filter_script option
Definition: ffmpeg.h:423
int audio_volume
Definition: ffmpeg_opt.c:86
misc parsing utilities
HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer. ...
Definition: pixfmt.h:142
size_t av_strlcat(char *dst, const char *src, size_t size)
Append the string src to the string dst, but to a total length of no more than size - 1 bytes...
Definition: avstring.c:93
uint16_t * inter_matrix
custom inter quantization matrix
Definition: avcodec.h:1792
static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2563
int end_frame
Definition: avcodec.h:688
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
Seek to timestamp ts.
Definition: utils.c:2154
static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:198
This struct describes the properties of a single codec described by an AVCodecID. ...
Definition: avcodec.h:558
double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max)
Parse a string and return its corresponding value as a double.
Definition: cmdutils.c:129
static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2369
char * name
unique name for this input/output in the list
Definition: avfilter.h:1351
const char * avio_find_protocol_name(const char *url)
Return the name of the protocol that will handle the passed URL.
Definition: avio.c:400
int nb_audio_channels
Definition: ffmpeg.h:100
#define OPT_TIME
Definition: cmdutils.h:179
int source_index
Definition: ffmpeg.h:377
int copy_prior_start
Definition: ffmpeg.h:436
SpecifierOpt * metadata
Definition: ffmpeg.h:154
static AVCodec * choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
Definition: ffmpeg_opt.c:561
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:1319
const char * av_get_media_type_string(enum AVMediaType media_type)
Return a string describing the media_type enum, NULL if media_type is unknown.
Definition: utils.c:72
AVCodec * avcodec_find_decoder_by_name(const char *name)
Find a registered decoder with the specified name.
Definition: utils.c:2943
static int flags
Definition: cpu.c:47
static OutputStream * new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
Definition: ffmpeg_opt.c:1299
static int opt_attach(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:319
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
Definition: ffmpeg_opt.c:1219
int64_t start_time
Position of the first frame of the component, in AV_TIME_BASE fractional seconds. ...
Definition: avformat.h:1311
int av_strerror(int errnum, char *errbuf, size_t errbuf_size)
Put a description of the AVERROR code errnum in errbuf.
Definition: error.c:68
#define OFFSET(x)
Definition: ffmpeg_opt.c:2812
int resample_sample_fmt
Definition: ffmpeg.h:282
static int opt_video_frames(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2390
char * av_strtok(char *s, const char *delim, char **saveptr)
Split the string into several tokens which can be accessed by successive calls to av_strtok()...
Definition: avstring.c:184
int64_t start
Definition: avformat.h:1194
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1433
OSTFinished finished
Definition: ffmpeg.h:431
char * forced_keyframes
Definition: ffmpeg.h:409
int nb_frame_rates
Definition: ffmpeg.h:104
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_dlog(ac->avr,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> out
#define OPT_BOOL
Definition: cmdutils.h:162
int av_strstart(const char *str, const char *pfx, const char **ptr)
Return non-zero if pfx is a prefix of str.
Definition: avstring.c:34
int resample_width
Definition: ffmpeg.h:279
float dts_error_threshold
Definition: ffmpeg_opt.c:84
int vda_init(AVCodecContext *s)
Definition: ffmpeg_vda.c:105
#define CODEC_FLAG_EMU_EDGE
Definition: avcodec.h:742
Main libavformat public API header.
static uint8_t * get_line(AVIOContext *s)
Definition: ffmpeg_opt.c:1014
void print_error(const char *filename, int err)
Print an error message to stderr, indicating filename and a human readable description of the error c...
Definition: cmdutils.c:1017
preset
Definition: vf_curves.c:46
static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
Definition: ffmpeg_opt.c:1033
struct FilterGraph * graph
Definition: ffmpeg.h:224
static uint8_t * read_file(const char *filename)
Definition: ffmpeg_opt.c:1237
uint64_t limit_filesize
Definition: ffmpeg.h:459
#define OPT_INT
Definition: cmdutils.h:167
static int opt_target(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2226
AVDictionary * codec_opts
Definition: cmdutils.c:66
AVIOContext * progress_avio
Definition: ffmpeg.c:130
AVDictionary * format_opts
Definition: cmdutils.h:278
static int opt_video_standard(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:192
int reinit_filters
Definition: ffmpeg.h:308
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:430
int nb_frame_sizes
Definition: ffmpeg.h:106
OptionGroupList * groups
Definition: cmdutils.h:298
OptionGroup * g
Definition: ffmpeg.h:91
#define VSYNC_CFR
Definition: ffmpeg.h:53
static int video_disable
Definition: ffplay.c:312
int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
Read packets of a media file to get stream information.
Definition: utils.c:3019
static double c[64]
int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value, int flags)
Convenience wrapper for av_dict_set that converts the value to a string and stores it...
Definition: dict.c:139
AVStream * st
Definition: muxing.c:54
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:870
OptionGroup global_opts
Definition: cmdutils.h:296
const char ** attachments
Definition: ffmpeg.h:133
#define AV_OPT_SEARCH_FAKE_OBJ
The obj passed to av_opt_find() is fake – only a double pointer to AVClass instead of a required poi...
Definition: opt.h:611
AVRational time_base
time base in which the start/end timestamps are specified
Definition: avformat.h:1193
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:206
char * key
Definition: dict.h:87
int den
denominator
Definition: rational.h:45
int avcodec_get_context_defaults3(AVCodecContext *s, const AVCodec *codec)
Set the fields of the given AVCodecContext to default values corresponding to the given codec (defaul...
Definition: options.c:90
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: utils.c:3635
AVFormatContext * ctx
Definition: ffmpeg.h:334
int stream_index
Definition: ffmpeg.h:79
AVCodec * enc
Definition: ffmpeg.h:392
int nb_metadata_map
Definition: ffmpeg.h:183
int frame_bits_per_raw_sample
Definition: ffmpeg_opt.c:103
enum AVCodecID id
Definition: avcodec.h:559
#define GROW_ARRAY(array, nb_elems)
Definition: cmdutils.h:579
pixel format definitions
char * avfilter
Definition: ffmpeg.h:421
#define av_free(p)
enum AVCodecID data_codec_id
Forced Data codec_id.
Definition: avformat.h:1746
char * value
Definition: dict.h:88
int eof_reached
true if eof reached
Definition: avio.h:96
int len
static int opt_timecode(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2552
static void dump_attachment(AVStream *st, const char *filename)
Definition: ffmpeg_opt.c:762
int channels
number of audio channels
Definition: avcodec.h:1984
OptGroup
Definition: ffmpeg_opt.c:2706
int top_field_first
Definition: ffmpeg.h:401
OutputFilter ** outputs
Definition: ffmpeg.h:240
static const struct PPFilter filters[]
Definition: postprocess.c:137
InputFile ** input_files
Definition: ffmpeg.c:138
SpecifierOpt * max_frames
Definition: ffmpeg.h:156
int disabled
Definition: ffmpeg.h:77
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:220
AVDictionary * bsf_args
Definition: ffmpeg.h:429
#define PAL
Definition: bktr.c:65
AVFormatContext * ctx
Definition: ffmpeg.h:454
int avformat_open_input(AVFormatContext **ps, const char *url, AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
Definition: utils.c:401
static int opt_streamid(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:1585
void show_help_children(const AVClass *class, int flags)
Show help for all options with given flags in class and all its children.
Definition: cmdutils.c:191
static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc, const OutputStream *ost, enum AVMediaType type)
Definition: ffmpeg_opt.c:1285
uint64_t layout
int thread_queue_size
Definition: ffmpeg.h:114
union SpecifierOpt::@0 u
char * hwaccel_device
Definition: ffmpeg.h:312
AVDictionary * encoder_opts
Definition: ffmpeg.h:426
char * av_stream_get_recommended_encoder_configuration(const AVStream *s)
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:701
list ofile
Definition: normalize.py:8
float max_error_rate
Definition: ffmpeg_opt.c:104
AVDictionary * codec_opts
Definition: cmdutils.h:277
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1321
int read_yesno(void)
Return a positive value if a line read from standard input starts with [yY], otherwise return 0...
Definition: cmdutils.c:1852
static const char * video_codec_name
Definition: ffplay.c:334
float dts_delta_threshold
Definition: ffmpeg_opt.c:83
union OptionDef::@1 u
#define av_freep(p)
void INT64 start
Definition: avisynth_c.h:595
int sync_stream_index
Definition: ffmpeg.h:81
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key, ignoring the suffix of the found key string.
Definition: dict.h:72
#define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)
Definition: ffmpeg_opt.c:56
OutputFile ** output_files
Definition: ffmpeg.c:143
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
Definition: log.h:169
static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2408
const HWAccel hwaccels[]
Definition: ffmpeg_opt.c:66
static int no_file_overwrite
Definition: ffmpeg_opt.c:109
enum AVPixelFormat av_get_pix_fmt(const char *name)
Return the pixel format corresponding to name.
Definition: pixdesc.c:1962
int discard
Definition: ffmpeg.h:247
static int opt_map(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:222
#define OPT_PERFILE
Definition: cmdutils.h:173
int thread_queue_size
Definition: ffmpeg.h:354
#define OPT_INPUT
Definition: cmdutils.h:181
enum HWAccelID hwaccel_id
Definition: ffmpeg.h:311
static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2396
#define MKTAG(a, b, c, d)
Definition: common.h:319
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:872
int index
Definition: ffmpeg.h:376
static OutputStream * new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
Definition: ffmpeg_opt.c:1549
struct SwsContext * sws_opts
Definition: cmdutils.h:280
uint64_t resample_channel_layout
Definition: ffmpeg.h:285
int avio_closep(AVIOContext **s)
Close the resource accessed by the AVIOContext *s, free it and set the pointer pointing to it to NULL...
Definition: aviobuf.c:942
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:368
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:250
const char program_name[]
program name, defined by the program for show_version().
Definition: ffmpeg.c:106
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:241
#define AVFMT_NEEDNUMBER
Needs 'd' in filename.
Definition: avformat.h:431
InputStream ** input_streams
Definition: ffmpeg.c:136
discard nothing
Definition: avcodec.h:661
const char * name
Definition: opengl_enc.c:103
int subtitle_disable
Definition: ffmpeg.h:147
static OutputStream * new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
Definition: ffmpeg_opt.c:1536