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