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