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