git.sesse.net Git - ffmpeg/blob - fftools/ffmpeg_opt.c

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