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 const 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     const 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     const 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         const AVClass *priv_class;
1121         /* because we set audio_channels based on both the "ac" and
1122          * "channel_layout" options, we need to check that the specified
1123          * demuxer actually has the "channels" option before setting it */
1124         if (file_iformat && (priv_class = file_iformat->priv_class) &&
1125             av_opt_find(&priv_class, "channels", NULL, 0,
1126                         AV_OPT_SEARCH_FAKE_OBJ)) {
1127             av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
1128         }
1129     }
1130     if (o->nb_frame_rates) {
1131         const AVClass *priv_class;
1132         /* set the format-level framerate option;
1133          * this is important for video grabbers, e.g. x11 */
1134         if (file_iformat && (priv_class = file_iformat->priv_class) &&
1135             av_opt_find(&priv_class, "framerate", NULL, 0,
1136                         AV_OPT_SEARCH_FAKE_OBJ)) {
1137             av_dict_set(&o->g->format_opts, "framerate",
1138                         o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
1139         }
1140     }
1141     if (o->nb_frame_sizes) {
1142         av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
1143     }
1144     if (o->nb_frame_pix_fmts)
1145         av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
1146
1147     MATCH_PER_TYPE_OPT(codec_names, str,    video_codec_name, ic, "v");
1148     MATCH_PER_TYPE_OPT(codec_names, str,    audio_codec_name, ic, "a");
1149     MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
1150     MATCH_PER_TYPE_OPT(codec_names, str,     data_codec_name, ic, "d");
1151
1152     if (video_codec_name)
1153         ic->video_codec    = find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0);
1154     if (audio_codec_name)
1155         ic->audio_codec    = find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0);
1156     if (subtitle_codec_name)
1157         ic->subtitle_codec = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
1158     if (data_codec_name)
1159         ic->data_codec     = find_codec_or_die(data_codec_name    , AVMEDIA_TYPE_DATA    , 0);
1160
1161     ic->video_codec_id     = video_codec_name    ? ic->video_codec->id    : AV_CODEC_ID_NONE;
1162     ic->audio_codec_id     = audio_codec_name    ? ic->audio_codec->id    : AV_CODEC_ID_NONE;
1163     ic->subtitle_codec_id  = subtitle_codec_name ? ic->subtitle_codec->id : AV_CODEC_ID_NONE;
1164     ic->data_codec_id      = data_codec_name     ? ic->data_codec->id     : AV_CODEC_ID_NONE;
1165
1166     ic->flags |= AVFMT_FLAG_NONBLOCK;
1167     if (o->bitexact)
1168         ic->flags |= AVFMT_FLAG_BITEXACT;
1169     ic->interrupt_callback = int_cb;
1170
1171     if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
1172         av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
1173         scan_all_pmts_set = 1;
1174     }
1175     /* open the input file with generic avformat function */
1176     err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
1177     if (err < 0) {
1178         print_error(filename, err);
1179         if (err == AVERROR_PROTOCOL_NOT_FOUND)
1180             av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
1181         exit_program(1);
1182     }
1183     if (scan_all_pmts_set)
1184         av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
1185     remove_avoptions(&o->g->format_opts, o->g->codec_opts);
1186     assert_avoptions(o->g->format_opts);
1187
1188     /* apply forced codec ids */
1189     for (i = 0; i < ic->nb_streams; i++)
1190         choose_decoder(o, ic, ic->streams[i]);
1191
1192     if (find_stream_info) {
1193         AVDictionary **opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
1194         int orig_nb_streams = ic->nb_streams;
1195
1196         /* If not enough info to get the stream parameters, we decode the
1197            first frames to get it. (used in mpeg case for example) */
1198         ret = avformat_find_stream_info(ic, opts);
1199
1200         for (i = 0; i < orig_nb_streams; i++)
1201             av_dict_free(&opts[i]);
1202         av_freep(&opts);
1203
1204         if (ret < 0) {
1205             av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1206             if (ic->nb_streams == 0) {
1207                 avformat_close_input(&ic);
1208                 exit_program(1);
1209             }
1210         }
1211     }
1212
1213     if (o->start_time != AV_NOPTS_VALUE && o->start_time_eof != AV_NOPTS_VALUE) {
1214         av_log(NULL, AV_LOG_WARNING, "Cannot use -ss and -sseof both, using -ss for %s\n", filename);
1215         o->start_time_eof = AV_NOPTS_VALUE;
1216     }
1217
1218     if (o->start_time_eof != AV_NOPTS_VALUE) {
1219         if (o->start_time_eof >= 0) {
1220             av_log(NULL, AV_LOG_ERROR, "-sseof value must be negative; aborting\n");
1221             exit_program(1);
1222         }
1223         if (ic->duration > 0) {
1224             o->start_time = o->start_time_eof + ic->duration;
1225             if (o->start_time < 0) {
1226                 av_log(NULL, AV_LOG_WARNING, "-sseof value seeks to before start of file %s; ignored\n", filename);
1227                 o->start_time = AV_NOPTS_VALUE;
1228             }
1229         } else
1230             av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1231     }
1232     timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1233     /* add the stream start time */
1234     if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1235         timestamp += ic->start_time;
1236
1237     /* if seeking requested, we execute it */
1238     if (o->start_time != AV_NOPTS_VALUE) {
1239         int64_t seek_timestamp = timestamp;
1240
1241         if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1242             int dts_heuristic = 0;
1243             for (i=0; i<ic->nb_streams; i++) {
1244                 const AVCodecParameters *par = ic->streams[i]->codecpar;
1245                 if (par->video_delay) {
1246                     dts_heuristic = 1;
1247                     break;
1248                 }
1249             }
1250             if (dts_heuristic) {
1251                 seek_timestamp -= 3*AV_TIME_BASE / 23;
1252             }
1253         }
1254         ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1255         if (ret < 0) {
1256             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1257                    filename, (double)timestamp / AV_TIME_BASE);
1258         }
1259     }
1260
1261     /* update the current parameters so that they match the one of the input stream */
1262     add_input_streams(o, ic);
1263
1264     /* dump the file content */
1265     av_dump_format(ic, nb_input_files, filename, 0);
1266
1267     GROW_ARRAY(input_files, nb_input_files);
1268     f = av_mallocz(sizeof(*f));
1269     if (!f)
1270         exit_program(1);
1271     input_files[nb_input_files - 1] = f;
1272
1273     f->ctx        = ic;
1274     f->ist_index  = nb_input_streams - ic->nb_streams;
1275     f->start_time = o->start_time;
1276     f->recording_time = o->recording_time;
1277     f->input_ts_offset = o->input_ts_offset;
1278     f->ts_offset  = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1279     f->nb_streams = ic->nb_streams;
1280     f->rate_emu   = o->rate_emu;
1281     f->accurate_seek = o->accurate_seek;
1282     f->loop = o->loop;
1283     f->duration = 0;
1284     f->time_base = (AVRational){ 1, 1 };
1285     f->pkt = av_packet_alloc();
1286     if (!f->pkt)
1287         exit_program(1);
1288 #if HAVE_THREADS
1289     f->thread_queue_size = o->thread_queue_size;
1290 #endif
1291
1292     /* check if all codec options have been used */
1293     unused_opts = strip_specifiers(o->g->codec_opts);
1294     for (i = f->ist_index; i < nb_input_streams; i++) {
1295         e = NULL;
1296         while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1297                                 AV_DICT_IGNORE_SUFFIX)))
1298             av_dict_set(&unused_opts, e->key, NULL, 0);
1299     }
1300
1301     e = NULL;
1302     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1303         const AVClass *class = avcodec_get_class();
1304         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1305                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1306         const AVClass *fclass = avformat_get_class();
1307         const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1308                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1309         if (!option || foption)
1310             continue;
1311
1312
1313         if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1314             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1315                    "input file #%d (%s) is not a decoding option.\n", e->key,
1316                    option->help ? option->help : "", nb_input_files - 1,
1317                    filename);
1318             exit_program(1);
1319         }
1320
1321         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1322                "input file #%d (%s) has not been used for any stream. The most "
1323                "likely reason is either wrong type (e.g. a video option with "
1324                "no video streams) or that it is a private option of some decoder "
1325                "which was not actually used for any stream.\n", e->key,
1326                option->help ? option->help : "", nb_input_files - 1, filename);
1327     }
1328     av_dict_free(&unused_opts);
1329
1330     for (i = 0; i < o->nb_dump_attachment; i++) {
1331         int j;
1332
1333         for (j = 0; j < ic->nb_streams; j++) {
1334             AVStream *st = ic->streams[j];
1335
1336             if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1337                 dump_attachment(st, o->dump_attachment[i].u.str);
1338         }
1339     }
1340
1341     input_stream_potentially_available = 1;
1342
1343     return 0;
1344 }
1345
1346 static uint8_t *get_line(AVIOContext *s)
1347 {
1348     AVIOContext *line;
1349     uint8_t *buf;
1350     char c;
1351
1352     if (avio_open_dyn_buf(&line) < 0) {
1353         av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1354         exit_program(1);
1355     }
1356
1357     while ((c = avio_r8(s)) && c != '\n')
1358         avio_w8(line, c);
1359     avio_w8(line, 0);
1360     avio_close_dyn_buf(line, &buf);
1361
1362     return buf;
1363 }
1364
1365 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1366 {
1367     int i, ret = -1;
1368     char filename[1000];
1369     const char *base[3] = { getenv("AVCONV_DATADIR"),
1370                             getenv("HOME"),
1371                             AVCONV_DATADIR,
1372                             };
1373
1374     for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1375         if (!base[i])
1376             continue;
1377         if (codec_name) {
1378             snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1379                      i != 1 ? "" : "/.avconv", codec_name, preset_name);
1380             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1381         }
1382         if (ret < 0) {
1383             snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1384                      i != 1 ? "" : "/.avconv", preset_name);
1385             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1386         }
1387     }
1388     return ret;
1389 }
1390
1391 static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1392 {
1393     enum AVMediaType type = ost->st->codecpar->codec_type;
1394     char *codec_name = NULL;
1395
1396     if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1397         MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1398         if (!codec_name) {
1399             ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->url,
1400                                                          NULL, ost->st->codecpar->codec_type);
1401             ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
1402             if (!ost->enc) {
1403                 av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1404                        "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1405                        "probably disabled. Please choose an encoder manually.\n",
1406                        ost->file_index, ost->index, s->oformat->name,
1407                        avcodec_get_name(ost->st->codecpar->codec_id));
1408                 return AVERROR_ENCODER_NOT_FOUND;
1409             }
1410         } else if (!strcmp(codec_name, "copy"))
1411             ost->stream_copy = 1;
1412         else {
1413             ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
1414             ost->st->codecpar->codec_id = ost->enc->id;
1415         }
1416         ost->encoding_needed = !ost->stream_copy;
1417     } else {
1418         /* no encoding supported for other media types */
1419         ost->stream_copy     = 1;
1420         ost->encoding_needed = 0;
1421     }
1422
1423     return 0;
1424 }
1425
1426 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1427 {
1428     OutputStream *ost;
1429     AVStream *st = avformat_new_stream(oc, NULL);
1430     int idx      = oc->nb_streams - 1, ret = 0;
1431     const char *bsfs = NULL, *time_base = NULL;
1432     char *next, *codec_tag = NULL;
1433     double qscale = -1;
1434     int i;
1435
1436     if (!st) {
1437         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1438         exit_program(1);
1439     }
1440
1441     if (oc->nb_streams - 1 < o->nb_streamid_map)
1442         st->id = o->streamid_map[oc->nb_streams - 1];
1443
1444     GROW_ARRAY(output_streams, nb_output_streams);
1445     if (!(ost = av_mallocz(sizeof(*ost))))
1446         exit_program(1);
1447     output_streams[nb_output_streams - 1] = ost;
1448
1449     ost->file_index = nb_output_files - 1;
1450     ost->index      = idx;
1451     ost->st         = st;
1452     ost->forced_kf_ref_pts = AV_NOPTS_VALUE;
1453     st->codecpar->codec_type = type;
1454
1455     ret = choose_encoder(o, oc, ost);
1456     if (ret < 0) {
1457         av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1458                "%d:%d\n", ost->file_index, ost->index);
1459         exit_program(1);
1460     }
1461
1462     ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1463     if (!ost->enc_ctx) {
1464         av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1465         exit_program(1);
1466     }
1467     ost->enc_ctx->codec_type = type;
1468
1469     ost->ref_par = avcodec_parameters_alloc();
1470     if (!ost->ref_par) {
1471         av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n");
1472         exit_program(1);
1473     }
1474
1475     if (ost->enc) {
1476         AVIOContext *s = NULL;
1477         char *buf = NULL, *arg = NULL, *preset = NULL;
1478
1479         ost->encoder_opts  = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1480
1481         MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1482         ost->autoscale = 1;
1483         MATCH_PER_STREAM_OPT(autoscale, i, ost->autoscale, oc, st);
1484         if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1485             do  {
1486                 buf = get_line(s);
1487                 if (!buf[0] || buf[0] == '#') {
1488                     av_free(buf);
1489                     continue;
1490                 }
1491                 if (!(arg = strchr(buf, '='))) {
1492                     av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1493                     exit_program(1);
1494                 }
1495                 *arg++ = 0;
1496                 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1497                 av_free(buf);
1498             } while (!s->eof_reached);
1499             avio_closep(&s);
1500         }
1501         if (ret) {
1502             av_log(NULL, AV_LOG_FATAL,
1503                    "Preset %s specified for stream %d:%d, but could not be opened.\n",
1504                    preset, ost->file_index, ost->index);
1505             exit_program(1);
1506         }
1507     } else {
1508         ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1509     }
1510
1511
1512     if (o->bitexact)
1513         ost->enc_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
1514
1515     MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1516     if (time_base) {
1517         AVRational q;
1518         if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1519             q.num <= 0 || q.den <= 0) {
1520             av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1521             exit_program(1);
1522         }
1523         st->time_base = q;
1524     }
1525
1526     MATCH_PER_STREAM_OPT(enc_time_bases, str, time_base, oc, st);
1527     if (time_base) {
1528         AVRational q;
1529         if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1530             q.den <= 0) {
1531             av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1532             exit_program(1);
1533         }
1534         ost->enc_timebase = q;
1535     }
1536
1537     ost->max_frames = INT64_MAX;
1538     MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1539     for (i = 0; i<o->nb_max_frames; i++) {
1540         char *p = o->max_frames[i].specifier;
1541         if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1542             av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1543             break;
1544         }
1545     }
1546
1547     ost->copy_prior_start = -1;
1548     MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1549
1550     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1551     if (bsfs && *bsfs) {
1552         ret = av_bsf_list_parse_str(bsfs, &ost->bsf_ctx);
1553         if (ret < 0) {
1554             av_log(NULL, AV_LOG_ERROR, "Error parsing bitstream filter sequence '%s': %s\n", bsfs, av_err2str(ret));
1555             exit_program(1);
1556         }
1557     }
1558
1559     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1560     if (codec_tag) {
1561         uint32_t tag = strtol(codec_tag, &next, 0);
1562         if (*next)
1563             tag = AV_RL32(codec_tag);
1564         ost->st->codecpar->codec_tag =
1565         ost->enc_ctx->codec_tag = tag;
1566     }
1567
1568     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1569     if (qscale >= 0) {
1570         ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1571         ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1572     }
1573
1574     MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1575     ost->disposition = av_strdup(ost->disposition);
1576
1577     ost->max_muxing_queue_size = 128;
1578     MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1579     ost->max_muxing_queue_size *= sizeof(ost->pkt);
1580
1581     ost->muxing_queue_data_size = 0;
1582
1583     ost->muxing_queue_data_threshold = 50*1024*1024;
1584     MATCH_PER_STREAM_OPT(muxing_queue_data_threshold, i, ost->muxing_queue_data_threshold, oc, st);
1585
1586     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1587         ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1588
1589     av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1590
1591     av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1592     if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1593         av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1594
1595     av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1596
1597     ost->source_index = source_index;
1598     if (source_index >= 0) {
1599         ost->sync_ist = input_streams[source_index];
1600         input_streams[source_index]->discard = 0;
1601         input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1602     }
1603     ost->last_mux_dts = AV_NOPTS_VALUE;
1604
1605     ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1606     if (!ost->muxing_queue)
1607         exit_program(1);
1608
1609     return ost;
1610 }
1611
1612 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1613 {
1614     int i;
1615     const char *p = str;
1616     for (i = 0;; i++) {
1617         dest[i] = atoi(p);
1618         if (i == 63)
1619             break;
1620         p = strchr(p, ',');
1621         if (!p) {
1622             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1623             exit_program(1);
1624         }
1625         p++;
1626     }
1627 }
1628
1629 /* read file contents into a string */
1630 static uint8_t *read_file(const char *filename)
1631 {
1632     AVIOContext *pb      = NULL;
1633     AVIOContext *dyn_buf = NULL;
1634     int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1635     uint8_t buf[1024], *str;
1636
1637     if (ret < 0) {
1638         av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1639         return NULL;
1640     }
1641
1642     ret = avio_open_dyn_buf(&dyn_buf);
1643     if (ret < 0) {
1644         avio_closep(&pb);
1645         return NULL;
1646     }
1647     while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1648         avio_write(dyn_buf, buf, ret);
1649     avio_w8(dyn_buf, 0);
1650     avio_closep(&pb);
1651
1652     ret = avio_close_dyn_buf(dyn_buf, &str);
1653     if (ret < 0)
1654         return NULL;
1655     return str;
1656 }
1657
1658 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1659                              OutputStream *ost)
1660 {
1661     AVStream *st = ost->st;
1662
1663     if (ost->filters_script && ost->filters) {
1664         av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1665                "output stream #%d:%d.\n", nb_output_files, st->index);
1666         exit_program(1);
1667     }
1668
1669     if (ost->filters_script)
1670         return read_file(ost->filters_script);
1671     else if (ost->filters)
1672         return av_strdup(ost->filters);
1673
1674     return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1675                      "null" : "anull");
1676 }
1677
1678 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1679                                      const OutputStream *ost, enum AVMediaType type)
1680 {
1681     if (ost->filters_script || ost->filters) {
1682         av_log(NULL, AV_LOG_ERROR,
1683                "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1684                "Filtering and streamcopy cannot be used together.\n",
1685                ost->filters ? "Filtergraph" : "Filtergraph script",
1686                ost->filters ? ost->filters : ost->filters_script,
1687                av_get_media_type_string(type), ost->file_index, ost->index);
1688         exit_program(1);
1689     }
1690 }
1691
1692 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1693 {
1694     AVStream *st;
1695     OutputStream *ost;
1696     AVCodecContext *video_enc;
1697     char *frame_rate = NULL, *max_frame_rate = NULL, *frame_aspect_ratio = NULL;
1698
1699     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1700     st  = ost->st;
1701     video_enc = ost->enc_ctx;
1702
1703     MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1704     if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1705         av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1706         exit_program(1);
1707     }
1708
1709     MATCH_PER_STREAM_OPT(max_frame_rates, str, max_frame_rate, oc, st);
1710     if (max_frame_rate && av_parse_video_rate(&ost->max_frame_rate, max_frame_rate) < 0) {
1711         av_log(NULL, AV_LOG_FATAL, "Invalid maximum framerate value: %s\n", max_frame_rate);
1712         exit_program(1);
1713     }
1714
1715     if (frame_rate && max_frame_rate) {
1716         av_log(NULL, AV_LOG_ERROR, "Only one of -fpsmax and -r can be set for a stream.\n");
1717         exit_program(1);
1718     }
1719
1720     if ((frame_rate || max_frame_rate) &&
1721         video_sync_method == VSYNC_PASSTHROUGH)
1722         av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r/-fpsmax can produce invalid output files\n");
1723
1724     MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1725     if (frame_aspect_ratio) {
1726         AVRational q;
1727         if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1728             q.num <= 0 || q.den <= 0) {
1729             av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1730             exit_program(1);
1731         }
1732         ost->frame_aspect_ratio = q;
1733     }
1734
1735     MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1736     MATCH_PER_STREAM_OPT(filters,        str, ost->filters,        oc, st);
1737
1738     if (!ost->stream_copy) {
1739         const char *p = NULL;
1740         char *frame_size = NULL;
1741         char *frame_pix_fmt = NULL;
1742         char *intra_matrix = NULL, *inter_matrix = NULL;
1743         char *chroma_intra_matrix = NULL;
1744         int do_pass = 0;
1745         int i;
1746
1747         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1748         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1749             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1750             exit_program(1);
1751         }
1752
1753         video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1754         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1755         if (frame_pix_fmt && *frame_pix_fmt == '+') {
1756             ost->keep_pix_fmt = 1;
1757             if (!*++frame_pix_fmt)
1758                 frame_pix_fmt = NULL;
1759         }
1760         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1761             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1762             exit_program(1);
1763         }
1764         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1765
1766         if (intra_only)
1767             video_enc->gop_size = 0;
1768         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1769         if (intra_matrix) {
1770             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1771                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1772                 exit_program(1);
1773             }
1774             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1775         }
1776         MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1777         if (chroma_intra_matrix) {
1778             uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1779             if (!p) {
1780                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1781                 exit_program(1);
1782             }
1783             video_enc->chroma_intra_matrix = p;
1784             parse_matrix_coeffs(p, chroma_intra_matrix);
1785         }
1786         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1787         if (inter_matrix) {
1788             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1789                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1790                 exit_program(1);
1791             }
1792             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1793         }
1794
1795         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1796         for (i = 0; p; i++) {
1797             int start, end, q;
1798             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1799             if (e != 3) {
1800                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1801                 exit_program(1);
1802             }
1803             video_enc->rc_override =
1804                 av_realloc_array(video_enc->rc_override,
1805                                  i + 1, sizeof(RcOverride));
1806             if (!video_enc->rc_override) {
1807                 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1808                 exit_program(1);
1809             }
1810             video_enc->rc_override[i].start_frame = start;
1811             video_enc->rc_override[i].end_frame   = end;
1812             if (q > 0) {
1813                 video_enc->rc_override[i].qscale         = q;
1814                 video_enc->rc_override[i].quality_factor = 1.0;
1815             }
1816             else {
1817                 video_enc->rc_override[i].qscale         = 0;
1818                 video_enc->rc_override[i].quality_factor = -q/100.0;
1819             }
1820             p = strchr(p, '/');
1821             if (p) p++;
1822         }
1823         video_enc->rc_override_count = i;
1824
1825         if (do_psnr)
1826             video_enc->flags|= AV_CODEC_FLAG_PSNR;
1827
1828         /* two pass mode */
1829         MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1830         if (do_pass) {
1831             if (do_pass & 1) {
1832                 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1833                 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1834             }
1835             if (do_pass & 2) {
1836                 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1837                 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1838             }
1839         }
1840
1841         MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1842         if (ost->logfile_prefix &&
1843             !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1844             exit_program(1);
1845
1846         if (do_pass) {
1847             char logfilename[1024];
1848             FILE *f;
1849
1850             snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1851                      ost->logfile_prefix ? ost->logfile_prefix :
1852                                            DEFAULT_PASS_LOGFILENAME_PREFIX,
1853                      i);
1854             if (!strcmp(ost->enc->name, "libx264")) {
1855                 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1856             } else {
1857                 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1858                     char  *logbuffer = read_file(logfilename);
1859
1860                     if (!logbuffer) {
1861                         av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1862                                logfilename);
1863                         exit_program(1);
1864                     }
1865                     video_enc->stats_in = logbuffer;
1866                 }
1867                 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1868                     f = av_fopen_utf8(logfilename, "wb");
1869                     if (!f) {
1870                         av_log(NULL, AV_LOG_FATAL,
1871                                "Cannot write log file '%s' for pass-1 encoding: %s\n",
1872                                logfilename, strerror(errno));
1873                         exit_program(1);
1874                     }
1875                     ost->logfile = f;
1876                 }
1877             }
1878         }
1879
1880         MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1881         if (ost->forced_keyframes)
1882             ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1883
1884         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1885
1886         ost->top_field_first = -1;
1887         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1888
1889
1890         ost->avfilter = get_ost_filters(o, oc, ost);
1891         if (!ost->avfilter)
1892             exit_program(1);
1893     } else {
1894         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1895     }
1896
1897     if (ost->stream_copy)
1898         check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1899
1900     return ost;
1901 }
1902
1903 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1904 {
1905     int n;
1906     AVStream *st;
1907     OutputStream *ost;
1908     AVCodecContext *audio_enc;
1909
1910     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1911     st  = ost->st;
1912
1913     audio_enc = ost->enc_ctx;
1914     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1915
1916     MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1917     MATCH_PER_STREAM_OPT(filters,        str, ost->filters,        oc, st);
1918
1919     if (!ost->stream_copy) {
1920         char *sample_fmt = NULL;
1921
1922         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1923
1924         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1925         if (sample_fmt &&
1926             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1927             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1928             exit_program(1);
1929         }
1930
1931         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1932
1933         MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1934         ost->apad = av_strdup(ost->apad);
1935
1936         ost->avfilter = get_ost_filters(o, oc, ost);
1937         if (!ost->avfilter)
1938             exit_program(1);
1939
1940         /* check for channel mapping for this audio stream */
1941         for (n = 0; n < o->nb_audio_channel_maps; n++) {
1942             AudioChannelMap *map = &o->audio_channel_maps[n];
1943             if ((map->ofile_idx   == -1 || ost->file_index == map->ofile_idx) &&
1944                 (map->ostream_idx == -1 || ost->st->index  == map->ostream_idx)) {
1945                 InputStream *ist;
1946
1947                 if (map->channel_idx == -1) {
1948                     ist = NULL;
1949                 } else if (ost->source_index < 0) {
1950                     av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1951                            ost->file_index, ost->st->index);
1952                     continue;
1953                 } else {
1954                     ist = input_streams[ost->source_index];
1955                 }
1956
1957                 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1958                     if (av_reallocp_array(&ost->audio_channels_map,
1959                                           ost->audio_channels_mapped + 1,
1960                                           sizeof(*ost->audio_channels_map)
1961                                           ) < 0 )
1962                         exit_program(1);
1963
1964                     ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1965                 }
1966             }
1967         }
1968     }
1969
1970     if (ost->stream_copy)
1971         check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1972
1973     return ost;
1974 }
1975
1976 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1977 {
1978     OutputStream *ost;
1979
1980     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1981     if (!ost->stream_copy) {
1982         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1983         exit_program(1);
1984     }
1985
1986     return ost;
1987 }
1988
1989 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1990 {
1991     OutputStream *ost;
1992
1993     ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1994     if (!ost->stream_copy) {
1995         av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1996         exit_program(1);
1997     }
1998
1999     return ost;
2000 }
2001
2002 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
2003 {
2004     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
2005     ost->stream_copy = 1;
2006     ost->finished    = 1;
2007     return ost;
2008 }
2009
2010 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
2011 {
2012     AVStream *st;
2013     OutputStream *ost;
2014     AVCodecContext *subtitle_enc;
2015
2016     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
2017     st  = ost->st;
2018     subtitle_enc = ost->enc_ctx;
2019
2020     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
2021
2022     MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
2023
2024     if (!ost->stream_copy) {
2025         char *frame_size = NULL;
2026
2027         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
2028         if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
2029             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
2030             exit_program(1);
2031         }
2032     }
2033
2034     return ost;
2035 }
2036
2037 /* arg format is "output-stream-index:streamid-value". */
2038 static int opt_streamid(void *optctx, const char *opt, const char *arg)
2039 {
2040     OptionsContext *o = optctx;
2041     int idx;
2042     char *p;
2043     char idx_str[16];
2044
2045     av_strlcpy(idx_str, arg, sizeof(idx_str));
2046     p = strchr(idx_str, ':');
2047     if (!p) {
2048         av_log(NULL, AV_LOG_FATAL,
2049                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
2050                arg, opt);
2051         exit_program(1);
2052     }
2053     *p++ = '\0';
2054     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
2055     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
2056     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
2057     return 0;
2058 }
2059
2060 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
2061 {
2062     AVFormatContext *is = ifile->ctx;
2063     AVFormatContext *os = ofile->ctx;
2064     AVChapter **tmp;
2065     int i;
2066
2067     tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
2068     if (!tmp)
2069         return AVERROR(ENOMEM);
2070     os->chapters = tmp;
2071
2072     for (i = 0; i < is->nb_chapters; i++) {
2073         AVChapter *in_ch = is->chapters[i], *out_ch;
2074         int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
2075         int64_t ts_off   = av_rescale_q(start_time - ifile->ts_offset,
2076                                        AV_TIME_BASE_Q, in_ch->time_base);
2077         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
2078                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
2079
2080
2081         if (in_ch->end < ts_off)
2082             continue;
2083         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
2084             break;
2085
2086         out_ch = av_mallocz(sizeof(AVChapter));
2087         if (!out_ch)
2088             return AVERROR(ENOMEM);
2089
2090         out_ch->id        = in_ch->id;
2091         out_ch->time_base = in_ch->time_base;
2092         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
2093         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
2094
2095         if (copy_metadata)
2096             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
2097
2098         os->chapters[os->nb_chapters++] = out_ch;
2099     }
2100     return 0;
2101 }
2102
2103 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
2104                                AVFormatContext *oc)
2105 {
2106     OutputStream *ost;
2107
2108     switch (ofilter->type) {
2109     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
2110     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
2111     default:
2112         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
2113                "currently.\n");
2114         exit_program(1);
2115     }
2116
2117     ost->source_index = -1;
2118     ost->filter       = ofilter;
2119
2120     ofilter->ost      = ost;
2121     ofilter->format   = -1;
2122
2123     if (ost->stream_copy) {
2124         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
2125                "which is fed from a complex filtergraph. Filtering and streamcopy "
2126                "cannot be used together.\n", ost->file_index, ost->index);
2127         exit_program(1);
2128     }
2129
2130     if (ost->avfilter && (ost->filters || ost->filters_script)) {
2131         const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
2132         av_log(NULL, AV_LOG_ERROR,
2133                "%s '%s' was specified through the %s option "
2134                "for output stream %d:%d, which is fed from a complex filtergraph.\n"
2135                "%s and -filter_complex cannot be used together for the same stream.\n",
2136                ost->filters ? "Filtergraph" : "Filtergraph script",
2137                ost->filters ? ost->filters : ost->filters_script,
2138                opt, ost->file_index, ost->index, opt);
2139         exit_program(1);
2140     }
2141
2142     avfilter_inout_free(&ofilter->out_tmp);
2143 }
2144
2145 static int init_complex_filters(void)
2146 {
2147     int i, ret = 0;
2148
2149     for (i = 0; i < nb_filtergraphs; i++) {
2150         ret = init_complex_filtergraph(filtergraphs[i]);
2151         if (ret < 0)
2152             return ret;
2153     }
2154     return 0;
2155 }
2156
2157 static int open_output_file(OptionsContext *o, const char *filename)
2158 {
2159     AVFormatContext *oc;
2160     int i, j, err;
2161     OutputFile *of;
2162     OutputStream *ost;
2163     InputStream  *ist;
2164     AVDictionary *unused_opts = NULL;
2165     AVDictionaryEntry *e = NULL;
2166     int format_flags = 0;
2167
2168     if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2169         o->stop_time = INT64_MAX;
2170         av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2171     }
2172
2173     if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2174         int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2175         if (o->stop_time <= start_time) {
2176             av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2177             exit_program(1);
2178         } else {
2179             o->recording_time = o->stop_time - start_time;
2180         }
2181     }
2182
2183     GROW_ARRAY(output_files, nb_output_files);
2184     of = av_mallocz(sizeof(*of));
2185     if (!of)
2186         exit_program(1);
2187     output_files[nb_output_files - 1] = of;
2188
2189     of->ost_index      = nb_output_streams;
2190     of->recording_time = o->recording_time;
2191     of->start_time     = o->start_time;
2192     of->limit_filesize = o->limit_filesize;
2193     of->shortest       = o->shortest;
2194     av_dict_copy(&of->opts, o->g->format_opts, 0);
2195
2196     if (!strcmp(filename, "-"))
2197         filename = "pipe:";
2198
2199     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2200     if (!oc) {
2201         print_error(filename, err);
2202         exit_program(1);
2203     }
2204
2205     of->ctx = oc;
2206     if (o->recording_time != INT64_MAX)
2207         oc->duration = o->recording_time;
2208
2209     oc->interrupt_callback = int_cb;
2210
2211     e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2212     if (e) {
2213         const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2214         av_opt_eval_flags(oc, o, e->value, &format_flags);
2215     }
2216     if (o->bitexact) {
2217         format_flags |= AVFMT_FLAG_BITEXACT;
2218         oc->flags    |= AVFMT_FLAG_BITEXACT;
2219     }
2220
2221     /* create streams for all unlabeled output pads */
2222     for (i = 0; i < nb_filtergraphs; i++) {
2223         FilterGraph *fg = filtergraphs[i];
2224         for (j = 0; j < fg->nb_outputs; j++) {
2225             OutputFilter *ofilter = fg->outputs[j];
2226
2227             if (!ofilter->out_tmp || ofilter->out_tmp->name)
2228                 continue;
2229
2230             switch (ofilter->type) {
2231             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
2232             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
2233             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2234             }
2235             init_output_filter(ofilter, o, oc);
2236         }
2237     }
2238
2239     if (!o->nb_stream_maps) {
2240         char *subtitle_codec_name = NULL;
2241         /* pick the "best" stream of each type */
2242
2243         /* video: highest resolution */
2244         if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2245             int best_score = 0, idx = -1;
2246             int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2247             for (i = 0; i < nb_input_streams; i++) {
2248                 int score;
2249                 ist = input_streams[i];
2250                 score = ist->st->codecpar->width * ist->st->codecpar->height
2251                            + 100000000 * !!(ist->st->event_flags & AVSTREAM_EVENT_FLAG_NEW_PACKETS)
2252                            + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2253                 if (ist->user_set_discard == AVDISCARD_ALL)
2254                     continue;
2255                 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2256                     score = 1;
2257                 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2258                     score > best_score) {
2259                     if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2260                         continue;
2261                     best_score = score;
2262                     idx = i;
2263                 }
2264             }
2265             if (idx >= 0)
2266                 new_video_stream(o, oc, idx);
2267         }
2268
2269         /* audio: most channels */
2270         if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2271             int best_score = 0, idx = -1;
2272             for (i = 0; i < nb_input_streams; i++) {
2273                 int score;
2274                 ist = input_streams[i];
2275                 score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames
2276                         + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2277                 if (ist->user_set_discard == AVDISCARD_ALL)
2278                     continue;
2279                 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2280                     score > best_score) {
2281                     best_score = score;
2282                     idx = i;
2283                 }
2284             }
2285             if (idx >= 0)
2286                 new_audio_stream(o, oc, idx);
2287         }
2288
2289         /* subtitles: pick first */
2290         MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2291         if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2292             for (i = 0; i < nb_input_streams; i++)
2293                 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2294                     AVCodecDescriptor const *input_descriptor =
2295                         avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2296                     AVCodecDescriptor const *output_descriptor = NULL;
2297                     AVCodec const *output_codec =
2298                         avcodec_find_encoder(oc->oformat->subtitle_codec);
2299                     int input_props = 0, output_props = 0;
2300                     if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2301                         continue;
2302                     if (output_codec)
2303                         output_descriptor = avcodec_descriptor_get(output_codec->id);
2304                     if (input_descriptor)
2305                         input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2306                     if (output_descriptor)
2307                         output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2308                     if (subtitle_codec_name ||
2309                         input_props & output_props ||
2310                         // Map dvb teletext which has neither property to any output subtitle encoder
2311                         input_descriptor && output_descriptor &&
2312                         (!input_descriptor->props ||
2313                          !output_descriptor->props)) {
2314                         new_subtitle_stream(o, oc, i);
2315                         break;
2316                     }
2317                 }
2318         }
2319         /* Data only if codec id match */
2320         if (!o->data_disable ) {
2321             enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2322             for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2323                 if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2324                     continue;
2325                 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2326                     && input_streams[i]->st->codecpar->codec_id == codec_id )
2327                     new_data_stream(o, oc, i);
2328             }
2329         }
2330     } else {
2331         for (i = 0; i < o->nb_stream_maps; i++) {
2332             StreamMap *map = &o->stream_maps[i];
2333
2334             if (map->disabled)
2335                 continue;
2336
2337             if (map->linklabel) {
2338                 FilterGraph *fg;
2339                 OutputFilter *ofilter = NULL;
2340                 int j, k;
2341
2342                 for (j = 0; j < nb_filtergraphs; j++) {
2343                     fg = filtergraphs[j];
2344                     for (k = 0; k < fg->nb_outputs; k++) {
2345                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
2346                         if (out && !strcmp(out->name, map->linklabel)) {
2347                             ofilter = fg->outputs[k];
2348                             goto loop_end;
2349                         }
2350                     }
2351                 }
2352 loop_end:
2353                 if (!ofilter) {
2354                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2355                            "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2356                     exit_program(1);
2357                 }
2358                 init_output_filter(ofilter, o, oc);
2359             } else {
2360                 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2361
2362                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2363                 if (ist->user_set_discard == AVDISCARD_ALL) {
2364                     av_log(NULL, AV_LOG_FATAL, "Stream #%d:%d is disabled and cannot be mapped.\n",
2365                            map->file_index, map->stream_index);
2366                     exit_program(1);
2367                 }
2368                 if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2369                     continue;
2370                 if(o->   audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2371                     continue;
2372                 if(o->   video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2373                     continue;
2374                 if(o->    data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2375                     continue;
2376
2377                 ost = NULL;
2378                 switch (ist->st->codecpar->codec_type) {
2379                 case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
2380                 case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
2381                 case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
2382                 case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
2383                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2384                 case AVMEDIA_TYPE_UNKNOWN:
2385                     if (copy_unknown_streams) {
2386                         ost = new_unknown_stream   (o, oc, src_idx);
2387                         break;
2388                     }
2389                 default:
2390                     av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2391                            "Cannot map stream #%d:%d - unsupported type.\n",
2392                            map->file_index, map->stream_index);
2393                     if (!ignore_unknown_streams) {
2394                         av_log(NULL, AV_LOG_FATAL,
2395                                "If you want unsupported types ignored instead "
2396                                "of failing, please use the -ignore_unknown option\n"
2397                                "If you want them copied, please use -copy_unknown\n");
2398                         exit_program(1);
2399                     }
2400                 }
2401                 if (ost)
2402                     ost->sync_ist = input_streams[  input_files[map->sync_file_index]->ist_index
2403                                                   + map->sync_stream_index];
2404             }
2405         }
2406     }
2407
2408     /* handle attached files */
2409     for (i = 0; i < o->nb_attachments; i++) {
2410         AVIOContext *pb;
2411         uint8_t *attachment;
2412         const char *p;
2413         int64_t len;
2414
2415         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2416             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2417                    o->attachments[i]);
2418             exit_program(1);
2419         }
2420         if ((len = avio_size(pb)) <= 0) {
2421             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2422                    o->attachments[i]);
2423             exit_program(1);
2424         }
2425         if (len > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE ||
2426             !(attachment = av_malloc(len + AV_INPUT_BUFFER_PADDING_SIZE))) {
2427             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large.\n",
2428                    o->attachments[i]);
2429             exit_program(1);
2430         }
2431         avio_read(pb, attachment, len);
2432         memset(attachment + len, 0, AV_INPUT_BUFFER_PADDING_SIZE);
2433
2434         ost = new_attachment_stream(o, oc, -1);
2435         ost->stream_copy               = 0;
2436         ost->attachment_filename       = o->attachments[i];
2437         ost->st->codecpar->extradata      = attachment;
2438         ost->st->codecpar->extradata_size = len;
2439
2440         p = strrchr(o->attachments[i], '/');
2441         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2442         avio_closep(&pb);
2443     }
2444
2445     if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2446         av_dump_format(oc, nb_output_files - 1, oc->url, 1);
2447         av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2448         exit_program(1);
2449     }
2450
2451     /* check if all codec options have been used */
2452     unused_opts = strip_specifiers(o->g->codec_opts);
2453     for (i = of->ost_index; i < nb_output_streams; i++) {
2454         e = NULL;
2455         while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2456                                 AV_DICT_IGNORE_SUFFIX)))
2457             av_dict_set(&unused_opts, e->key, NULL, 0);
2458     }
2459
2460     e = NULL;
2461     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2462         const AVClass *class = avcodec_get_class();
2463         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2464                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2465         const AVClass *fclass = avformat_get_class();
2466         const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2467                                               AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2468         if (!option || foption)
2469             continue;
2470
2471
2472         if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2473             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2474                    "output file #%d (%s) is not an encoding option.\n", e->key,
2475                    option->help ? option->help : "", nb_output_files - 1,
2476                    filename);
2477             exit_program(1);
2478         }
2479
2480         // gop_timecode is injected by generic code but not always used
2481         if (!strcmp(e->key, "gop_timecode"))
2482             continue;
2483
2484         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2485                "output file #%d (%s) has not been used for any stream. The most "
2486                "likely reason is either wrong type (e.g. a video option with "
2487                "no video streams) or that it is a private option of some encoder "
2488                "which was not actually used for any stream.\n", e->key,
2489                option->help ? option->help : "", nb_output_files - 1, filename);
2490     }
2491     av_dict_free(&unused_opts);
2492
2493     /* set the decoding_needed flags and create simple filtergraphs */
2494     for (i = of->ost_index; i < nb_output_streams; i++) {
2495         OutputStream *ost = output_streams[i];
2496
2497         if (ost->encoding_needed && ost->source_index >= 0) {
2498             InputStream *ist = input_streams[ost->source_index];
2499             ist->decoding_needed |= DECODING_FOR_OST;
2500
2501             if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2502                 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2503                 err = init_simple_filtergraph(ist, ost);
2504                 if (err < 0) {
2505                     av_log(NULL, AV_LOG_ERROR,
2506                            "Error initializing a simple filtergraph between streams "
2507                            "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2508                            nb_output_files - 1, ost->st->index);
2509                     exit_program(1);
2510                 }
2511             }
2512         }
2513
2514         /* set the filter output constraints */
2515         if (ost->filter) {
2516             OutputFilter *f = ost->filter;
2517             int count;
2518             switch (ost->enc_ctx->codec_type) {
2519             case AVMEDIA_TYPE_VIDEO:
2520                 f->frame_rate = ost->frame_rate;
2521                 f->width      = ost->enc_ctx->width;
2522                 f->height     = ost->enc_ctx->height;
2523                 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2524                     f->format = ost->enc_ctx->pix_fmt;
2525                 } else if (ost->enc->pix_fmts) {
2526                     count = 0;
2527                     while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2528                         count++;
2529                     f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2530                     if (!f->formats)
2531                         exit_program(1);
2532                     memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2533                 }
2534                 break;
2535             case AVMEDIA_TYPE_AUDIO:
2536                 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2537                     f->format = ost->enc_ctx->sample_fmt;
2538                 } else if (ost->enc->sample_fmts) {
2539                     count = 0;
2540                     while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2541                         count++;
2542                     f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2543                     if (!f->formats)
2544                         exit_program(1);
2545                     memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2546                 }
2547                 if (ost->enc_ctx->sample_rate) {
2548                     f->sample_rate = ost->enc_ctx->sample_rate;
2549                 } else if (ost->enc->supported_samplerates) {
2550                     count = 0;
2551                     while (ost->enc->supported_samplerates[count])
2552                         count++;
2553                     f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2554                     if (!f->sample_rates)
2555                         exit_program(1);
2556                     memcpy(f->sample_rates, ost->enc->supported_samplerates,
2557                            (count + 1) * sizeof(*f->sample_rates));
2558                 }
2559                 if (ost->enc_ctx->channels) {
2560                     f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2561                 } else if (ost->enc->channel_layouts) {
2562                     count = 0;
2563                     while (ost->enc->channel_layouts[count])
2564                         count++;
2565                     f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2566                     if (!f->channel_layouts)
2567                         exit_program(1);
2568                     memcpy(f->channel_layouts, ost->enc->channel_layouts,
2569                            (count + 1) * sizeof(*f->channel_layouts));
2570                 }
2571                 break;
2572             }
2573         }
2574     }
2575
2576     /* check filename in case of an image number is expected */
2577     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2578         if (!av_filename_number_test(oc->url)) {
2579             print_error(oc->url, AVERROR(EINVAL));
2580             exit_program(1);
2581         }
2582     }
2583
2584     if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2585         av_log(NULL, AV_LOG_ERROR,
2586                "No input streams but output needs an input stream\n");
2587         exit_program(1);
2588     }
2589
2590     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2591         /* test if it already exists to avoid losing precious files */
2592         assert_file_overwrite(filename);
2593
2594         /* open the file */
2595         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2596                               &oc->interrupt_callback,
2597                               &of->opts)) < 0) {
2598             print_error(filename, err);
2599             exit_program(1);
2600         }
2601     } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2602         assert_file_overwrite(filename);
2603
2604     if (o->mux_preload) {
2605         av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2606     }
2607     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2608
2609     /* copy metadata */
2610     for (i = 0; i < o->nb_metadata_map; i++) {
2611         char *p;
2612         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2613
2614         if (in_file_index >= nb_input_files) {
2615             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2616             exit_program(1);
2617         }
2618         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2619                       in_file_index >= 0 ?
2620                       input_files[in_file_index]->ctx : NULL, o);
2621     }
2622
2623     /* copy chapters */
2624     if (o->chapters_input_file >= nb_input_files) {
2625         if (o->chapters_input_file == INT_MAX) {
2626             /* copy chapters from the first input file that has them*/
2627             o->chapters_input_file = -1;
2628             for (i = 0; i < nb_input_files; i++)
2629                 if (input_files[i]->ctx->nb_chapters) {
2630                     o->chapters_input_file = i;
2631                     break;
2632                 }
2633         } else {
2634             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2635                    o->chapters_input_file);
2636             exit_program(1);
2637         }
2638     }
2639     if (o->chapters_input_file >= 0)
2640         copy_chapters(input_files[o->chapters_input_file], of,
2641                       !o->metadata_chapters_manual);
2642
2643     /* copy global metadata by default */
2644     if (!o->metadata_global_manual && nb_input_files){
2645         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2646                      AV_DICT_DONT_OVERWRITE);
2647         if(o->recording_time != INT64_MAX)
2648             av_dict_set(&oc->metadata, "duration", NULL, 0);
2649         av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2650         av_dict_set(&oc->metadata, "company_name", NULL, 0);
2651         av_dict_set(&oc->metadata, "product_name", NULL, 0);
2652         av_dict_set(&oc->metadata, "product_version", NULL, 0);
2653     }
2654     if (!o->metadata_streams_manual)
2655         for (i = of->ost_index; i < nb_output_streams; i++) {
2656             InputStream *ist;
2657             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
2658                 continue;
2659             ist = input_streams[output_streams[i]->source_index];
2660             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2661             if (!output_streams[i]->stream_copy) {
2662                 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2663             }
2664         }
2665
2666     /* process manually set programs */
2667     for (i = 0; i < o->nb_program; i++) {
2668         const char *p = o->program[i].u.str;
2669         int progid = i+1;
2670         AVProgram *program;
2671
2672         while(*p) {
2673             const char *p2 = av_get_token(&p, ":");
2674             const char *to_dealloc = p2;
2675             char *key;
2676             if (!p2)
2677                 break;
2678
2679             if(*p) p++;
2680
2681             key = av_get_token(&p2, "=");
2682             if (!key || !*p2) {
2683                 av_freep(&to_dealloc);
2684                 av_freep(&key);
2685                 break;
2686             }
2687             p2++;
2688
2689             if (!strcmp(key, "program_num"))
2690                 progid = strtol(p2, NULL, 0);
2691             av_freep(&to_dealloc);
2692             av_freep(&key);
2693         }
2694
2695         program = av_new_program(oc, progid);
2696
2697         p = o->program[i].u.str;
2698         while(*p) {
2699             const char *p2 = av_get_token(&p, ":");
2700             const char *to_dealloc = p2;
2701             char *key;
2702             if (!p2)
2703                 break;
2704             if(*p) p++;
2705
2706             key = av_get_token(&p2, "=");
2707             if (!key) {
2708                 av_log(NULL, AV_LOG_FATAL,
2709                        "No '=' character in program string %s.\n",
2710                        p2);
2711                 exit_program(1);
2712             }
2713             if (!*p2)
2714                 exit_program(1);
2715             p2++;
2716
2717             if (!strcmp(key, "title")) {
2718                 av_dict_set(&program->metadata, "title", p2, 0);
2719             } else if (!strcmp(key, "program_num")) {
2720             } else if (!strcmp(key, "st")) {
2721                 int st_num = strtol(p2, NULL, 0);
2722                 av_program_add_stream_index(oc, progid, st_num);
2723             } else {
2724                 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2725                 exit_program(1);
2726             }
2727             av_freep(&to_dealloc);
2728             av_freep(&key);
2729         }
2730     }
2731
2732     /* process manually set metadata */
2733     for (i = 0; i < o->nb_metadata; i++) {
2734         AVDictionary **m;
2735         char type, *val;
2736         const char *stream_spec;
2737         int index = 0, j, ret = 0;
2738
2739         val = strchr(o->metadata[i].u.str, '=');
2740         if (!val) {
2741             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2742                    o->metadata[i].u.str);
2743             exit_program(1);
2744         }
2745         *val++ = 0;
2746
2747         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2748         if (type == 's') {
2749             for (j = 0; j < oc->nb_streams; j++) {
2750                 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2751                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2752                     if (!strcmp(o->metadata[i].u.str, "rotate")) {
2753                         char *tail;
2754                         double theta = av_strtod(val, &tail);
2755                         if (!*tail) {
2756                             ost->rotate_overridden = 1;
2757                             ost->rotate_override_value = theta;
2758                         }
2759                     } else {
2760                         av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2761                     }
2762                 } else if (ret < 0)
2763                     exit_program(1);
2764             }
2765         }
2766         else {
2767             switch (type) {
2768             case 'g':
2769                 m = &oc->metadata;
2770                 break;
2771             case 'c':
2772                 if (index < 0 || index >= oc->nb_chapters) {
2773                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2774                     exit_program(1);
2775                 }
2776                 m = &oc->chapters[index]->metadata;
2777                 break;
2778             case 'p':
2779                 if (index < 0 || index >= oc->nb_programs) {
2780                     av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2781                     exit_program(1);
2782                 }
2783                 m = &oc->programs[index]->metadata;
2784                 break;
2785             default:
2786                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2787                 exit_program(1);
2788             }
2789             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2790         }
2791     }
2792
2793     return 0;
2794 }
2795
2796 static int opt_target(void *optctx, const char *opt, const char *arg)
2797 {
2798     OptionsContext *o = optctx;
2799     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2800     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2801
2802     if (!strncmp(arg, "pal-", 4)) {
2803         norm = PAL;
2804         arg += 4;
2805     } else if (!strncmp(arg, "ntsc-", 5)) {
2806         norm = NTSC;
2807         arg += 5;
2808     } else if (!strncmp(arg, "film-", 5)) {
2809         norm = FILM;
2810         arg += 5;
2811     } else {
2812         /* Try to determine PAL/NTSC by peeking in the input files */
2813         if (nb_input_files) {
2814             int i, j;
2815             for (j = 0; j < nb_input_files; j++) {
2816                 for (i = 0; i < input_files[j]->nb_streams; i++) {
2817                     AVStream *st = input_files[j]->ctx->streams[i];
2818                     int64_t fr;
2819                     if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2820                         continue;
2821                     fr = st->time_base.den * 1000LL / st->time_base.num;
2822                     if (fr == 25000) {
2823                         norm = PAL;
2824                         break;
2825                     } else if ((fr == 29970) || (fr == 23976)) {
2826                         norm = NTSC;
2827                         break;
2828                     }
2829                 }
2830                 if (norm != UNKNOWN)
2831                     break;
2832             }
2833         }
2834         if (norm != UNKNOWN)
2835             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2836     }
2837
2838     if (norm == UNKNOWN) {
2839         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2840         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2841         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2842         exit_program(1);
2843     }
2844
2845     if (!strcmp(arg, "vcd")) {
2846         opt_video_codec(o, "c:v", "mpeg1video");
2847         opt_audio_codec(o, "c:a", "mp2");
2848         parse_option(o, "f", "vcd", options);
2849
2850         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2851         parse_option(o, "r", frame_rates[norm], options);
2852         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2853
2854         opt_default(NULL, "b:v", "1150000");
2855         opt_default(NULL, "maxrate:v", "1150000");
2856         opt_default(NULL, "minrate:v", "1150000");
2857         opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2858
2859         opt_default(NULL, "b:a", "224000");
2860         parse_option(o, "ar", "44100", options);
2861         parse_option(o, "ac", "2", options);
2862
2863         opt_default(NULL, "packetsize", "2324");
2864         opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2865
2866         /* We have to offset the PTS, so that it is consistent with the SCR.
2867            SCR starts at 36000, but the first two packs contain only padding
2868            and the first pack from the other stream, respectively, may also have
2869            been written before.
2870            So the real data starts at SCR 36000+3*1200. */
2871         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2872     } else if (!strcmp(arg, "svcd")) {
2873
2874         opt_video_codec(o, "c:v", "mpeg2video");
2875         opt_audio_codec(o, "c:a", "mp2");
2876         parse_option(o, "f", "svcd", options);
2877
2878         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2879         parse_option(o, "r", frame_rates[norm], options);
2880         parse_option(o, "pix_fmt", "yuv420p", options);
2881         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2882
2883         opt_default(NULL, "b:v", "2040000");
2884         opt_default(NULL, "maxrate:v", "2516000");
2885         opt_default(NULL, "minrate:v", "0"); // 1145000;
2886         opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2887         opt_default(NULL, "scan_offset", "1");
2888
2889         opt_default(NULL, "b:a", "224000");
2890         parse_option(o, "ar", "44100", options);
2891
2892         opt_default(NULL, "packetsize", "2324");
2893
2894     } else if (!strcmp(arg, "dvd")) {
2895
2896         opt_video_codec(o, "c:v", "mpeg2video");
2897         opt_audio_codec(o, "c:a", "ac3");
2898         parse_option(o, "f", "dvd", options);
2899
2900         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2901         parse_option(o, "r", frame_rates[norm], options);
2902         parse_option(o, "pix_fmt", "yuv420p", options);
2903         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2904
2905         opt_default(NULL, "b:v", "6000000");
2906         opt_default(NULL, "maxrate:v", "9000000");
2907         opt_default(NULL, "minrate:v", "0"); // 1500000;
2908         opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2909
2910         opt_default(NULL, "packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2911         opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2912
2913         opt_default(NULL, "b:a", "448000");
2914         parse_option(o, "ar", "48000", options);
2915
2916     } else if (!strncmp(arg, "dv", 2)) {
2917
2918         parse_option(o, "f", "dv", options);
2919
2920         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2921         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2922                           norm == PAL ? "yuv420p" : "yuv411p", options);
2923         parse_option(o, "r", frame_rates[norm], options);
2924
2925         parse_option(o, "ar", "48000", options);
2926         parse_option(o, "ac", "2", options);
2927
2928     } else {
2929         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2930         return AVERROR(EINVAL);
2931     }
2932
2933     av_dict_copy(&o->g->codec_opts,  codec_opts, AV_DICT_DONT_OVERWRITE);
2934     av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2935
2936     return 0;
2937 }
2938
2939 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2940 {
2941     av_free (vstats_filename);
2942     vstats_filename = av_strdup (arg);
2943     return 0;
2944 }
2945
2946 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2947 {
2948     char filename[40];
2949     time_t today2 = time(NULL);
2950     struct tm *today = localtime(&today2);
2951
2952     if (!today) { // maybe tomorrow
2953         av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2954         exit_program(1);
2955     }
2956
2957     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2958              today->tm_sec);
2959     return opt_vstats_file(NULL, opt, filename);
2960 }
2961
2962 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2963 {
2964     OptionsContext *o = optctx;
2965     return parse_option(o, "frames:v", arg, options);
2966 }
2967
2968 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2969 {
2970     OptionsContext *o = optctx;
2971     return parse_option(o, "frames:a", arg, options);
2972 }
2973
2974 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2975 {
2976     OptionsContext *o = optctx;
2977     return parse_option(o, "frames:d", arg, options);
2978 }
2979
2980 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2981 {
2982     int ret;
2983     AVDictionary *cbak = codec_opts;
2984     AVDictionary *fbak = format_opts;
2985     codec_opts = NULL;
2986     format_opts = NULL;
2987
2988     ret = opt_default(NULL, opt, arg);
2989
2990     av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2991     av_dict_copy(&o->g->format_opts, format_opts, 0);
2992     av_dict_free(&codec_opts);
2993     av_dict_free(&format_opts);
2994     codec_opts = cbak;
2995     format_opts = fbak;
2996
2997     return ret;
2998 }
2999
3000 static int opt_preset(void *optctx, const char *opt, const char *arg)
3001 {
3002     OptionsContext *o = optctx;
3003     FILE *f=NULL;
3004     char filename[1000], line[1000], tmp_line[1000];
3005     const char *codec_name = NULL;
3006
3007     tmp_line[0] = *opt;
3008     tmp_line[1] = 0;
3009     MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
3010
3011     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
3012         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
3013             av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
3014         }else
3015             av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
3016         exit_program(1);
3017     }
3018
3019     while (fgets(line, sizeof(line), f)) {
3020         char *key = tmp_line, *value, *endptr;
3021
3022         if (strcspn(line, "#\n\r") == 0)
3023             continue;
3024         av_strlcpy(tmp_line, line, sizeof(tmp_line));
3025         if (!av_strtok(key,   "=",    &value) ||
3026             !av_strtok(value, "\r\n", &endptr)) {
3027             av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
3028             exit_program(1);
3029         }
3030         av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
3031
3032         if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
3033         else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
3034         else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
3035         else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
3036         else if (opt_default_new(o, key, value) < 0) {
3037             av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
3038                    filename, line, key, value);
3039             exit_program(1);
3040         }
3041     }
3042
3043     fclose(f);
3044
3045     return 0;
3046 }
3047
3048 static int opt_old2new(void *optctx, const char *opt, const char *arg)
3049 {
3050     OptionsContext *o = optctx;
3051     int ret;
3052     char *s = av_asprintf("%s:%c", opt + 1, *opt);
3053     if (!s)
3054         return AVERROR(ENOMEM);
3055     ret = parse_option(o, s, arg, options);
3056     av_free(s);
3057     return ret;
3058 }
3059
3060 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
3061 {
3062     OptionsContext *o = optctx;
3063
3064     if(!strcmp(opt, "ab")){
3065         av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
3066         return 0;
3067     } else if(!strcmp(opt, "b")){
3068         av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
3069         av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
3070         return 0;
3071     }
3072     av_dict_set(&o->g->codec_opts, opt, arg, 0);
3073     return 0;
3074 }
3075
3076 static int opt_qscale(void *optctx, const char *opt, const char *arg)
3077 {
3078     OptionsContext *o = optctx;
3079     char *s;
3080     int ret;
3081     if(!strcmp(opt, "qscale")){
3082         av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
3083         return parse_option(o, "q:v", arg, options);
3084     }
3085     s = av_asprintf("q%s", opt + 6);
3086     if (!s)
3087         return AVERROR(ENOMEM);
3088     ret = parse_option(o, s, arg, options);
3089     av_free(s);
3090     return ret;
3091 }
3092
3093 static int opt_profile(void *optctx, const char *opt, const char *arg)
3094 {
3095     OptionsContext *o = optctx;
3096     if(!strcmp(opt, "profile")){
3097         av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
3098         av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
3099         return 0;
3100     }
3101     av_dict_set(&o->g->codec_opts, opt, arg, 0);
3102     return 0;
3103 }
3104
3105 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3106 {
3107     OptionsContext *o = optctx;
3108     return parse_option(o, "filter:v", arg, options);
3109 }
3110
3111 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3112 {
3113     OptionsContext *o = optctx;
3114     return parse_option(o, "filter:a", arg, options);
3115 }
3116
3117 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3118 {
3119     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
3120     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
3121     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3122     else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
3123
3124     if (video_sync_method == VSYNC_AUTO)
3125         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
3126     return 0;
3127 }
3128
3129 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3130 {
3131     OptionsContext *o = optctx;
3132     int ret;
3133     char *tcr = av_asprintf("timecode=%s", arg);
3134     if (!tcr)
3135         return AVERROR(ENOMEM);
3136     ret = parse_option(o, "metadata:g", tcr, options);
3137     if (ret >= 0)
3138         ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3139     av_free(tcr);
3140     return ret;
3141 }
3142
3143 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3144 {
3145     OptionsContext *o = optctx;
3146     char layout_str[32];
3147     char *stream_str;
3148     char *ac_str;
3149     int ret, channels, ac_str_size;
3150     uint64_t layout;
3151
3152     layout = av_get_channel_layout(arg);
3153     if (!layout) {
3154         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3155         return AVERROR(EINVAL);
3156     }
3157     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3158     ret = opt_default_new(o, opt, layout_str);
3159     if (ret < 0)
3160         return ret;
3161
3162     /* set 'ac' option based on channel layout */
3163     channels = av_get_channel_layout_nb_channels(layout);
3164     snprintf(layout_str, sizeof(layout_str), "%d", channels);
3165     stream_str = strchr(opt, ':');
3166     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3167     ac_str = av_mallocz(ac_str_size);
3168     if (!ac_str)
3169         return AVERROR(ENOMEM);
3170     av_strlcpy(ac_str, "ac", 3);
3171     if (stream_str)
3172         av_strlcat(ac_str, stream_str, ac_str_size);
3173     ret = parse_option(o, ac_str, layout_str, options);
3174     av_free(ac_str);
3175
3176     return ret;
3177 }
3178
3179 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3180 {
3181     OptionsContext *o = optctx;
3182     return parse_option(o, "q:a", arg, options);
3183 }
3184
3185 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3186 {
3187     GROW_ARRAY(filtergraphs, nb_filtergraphs);
3188     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3189         return AVERROR(ENOMEM);
3190     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
3191     filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
3192     if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3193         return AVERROR(ENOMEM);
3194
3195     input_stream_potentially_available = 1;
3196
3197     return 0;
3198 }
3199
3200 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3201 {
3202     uint8_t *graph_desc = read_file(arg);
3203     if (!graph_desc)
3204         return AVERROR(EINVAL);
3205
3206     GROW_ARRAY(filtergraphs, nb_filtergraphs);
3207     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3208         return AVERROR(ENOMEM);
3209     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
3210     filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3211
3212     input_stream_potentially_available = 1;
3213
3214     return 0;
3215 }
3216
3217 void show_help_default(const char *opt, const char *arg)
3218 {
3219     /* per-file options have at least one of those set */
3220     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3221     int show_advanced = 0, show_avoptions = 0;
3222
3223     if (opt && *opt) {
3224         if (!strcmp(opt, "long"))
3225             show_advanced = 1;
3226         else if (!strcmp(opt, "full"))
3227             show_advanced = show_avoptions = 1;
3228         else
3229             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3230     }
3231
3232     show_usage();
3233
3234     printf("Getting help:\n"
3235            "    -h      -- print basic options\n"
3236            "    -h long -- print more options\n"
3237            "    -h full -- print all options (including all format and codec specific options, very long)\n"
3238            "    -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter/bsf/protocol\n"
3239            "    See man %s for detailed description of the options.\n"
3240            "\n", program_name);
3241
3242     show_help_options(options, "Print help / information / capabilities:",
3243                       OPT_EXIT, 0, 0);
3244
3245     show_help_options(options, "Global options (affect whole program "
3246                       "instead of just one file):",
3247                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3248     if (show_advanced)
3249         show_help_options(options, "Advanced global options:", OPT_EXPERT,
3250                           per_file | OPT_EXIT, 0);
3251
3252     show_help_options(options, "Per-file main options:", 0,
3253                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3254                       OPT_EXIT, per_file);
3255     if (show_advanced)
3256         show_help_options(options, "Advanced per-file options:",
3257                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3258
3259     show_help_options(options, "Video options:",
3260                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3261     if (show_advanced)
3262         show_help_options(options, "Advanced Video options:",
3263                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3264
3265     show_help_options(options, "Audio options:",
3266                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3267     if (show_advanced)
3268         show_help_options(options, "Advanced Audio options:",
3269                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3270     show_help_options(options, "Subtitle options:",
3271                       OPT_SUBTITLE, 0, 0);
3272     printf("\n");
3273
3274     if (show_avoptions) {
3275         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3276         show_help_children(avcodec_get_class(), flags);
3277         show_help_children(avformat_get_class(), flags);
3278 #if CONFIG_SWSCALE
3279         show_help_children(sws_get_class(), flags);
3280 #endif
3281 #if CONFIG_SWRESAMPLE
3282         show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3283 #endif
3284         show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3285         show_help_children(av_bsf_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_BSF_PARAM);
3286     }
3287 }
3288
3289 void show_usage(void)
3290 {
3291     av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3292     av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3293     av_log(NULL, AV_LOG_INFO, "\n");
3294 }
3295
3296 enum OptGroup {
3297     GROUP_OUTFILE,
3298     GROUP_INFILE,
3299 };
3300
3301 static const OptionGroupDef groups[] = {
3302     [GROUP_OUTFILE] = { "output url",  NULL, OPT_OUTPUT },
3303     [GROUP_INFILE]  = { "input url",   "i",  OPT_INPUT },
3304 };
3305
3306 static int open_files(OptionGroupList *l, const char *inout,
3307                       int (*open_file)(OptionsContext*, const char*))
3308 {
3309     int i, ret;
3310
3311     for (i = 0; i < l->nb_groups; i++) {
3312         OptionGroup *g = &l->groups[i];
3313         OptionsContext o;
3314
3315         init_options(&o);
3316         o.g = g;
3317
3318         ret = parse_optgroup(&o, g);
3319         if (ret < 0) {
3320             av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3321                    "%s.\n", inout, g->arg);
3322             uninit_options(&o);
3323             return ret;
3324         }
3325
3326         av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3327         ret = open_file(&o, g->arg);
3328         uninit_options(&o);
3329         if (ret < 0) {
3330             av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3331                    inout, g->arg);
3332             return ret;
3333         }
3334         av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3335     }
3336
3337     return 0;
3338 }
3339
3340 int ffmpeg_parse_options(int argc, char **argv)
3341 {
3342     OptionParseContext octx;
3343     uint8_t error[128];
3344     int ret;
3345
3346     memset(&octx, 0, sizeof(octx));
3347
3348     /* split the commandline into an internal representation */
3349     ret = split_commandline(&octx, argc, argv, options, groups,
3350                             FF_ARRAY_ELEMS(groups));
3351     if (ret < 0) {
3352         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3353         goto fail;
3354     }
3355
3356     /* apply global options */
3357     ret = parse_optgroup(NULL, &octx.global_opts);
3358     if (ret < 0) {
3359         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3360         goto fail;
3361     }
3362
3363     /* configure terminal and setup signal handlers */
3364     term_init();
3365
3366     /* open input files */
3367     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3368     if (ret < 0) {
3369         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3370         goto fail;
3371     }
3372
3373     /* create the complex filtergraphs */
3374     ret = init_complex_filters();
3375     if (ret < 0) {
3376         av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3377         goto fail;
3378     }
3379
3380     /* open output files */
3381     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3382     if (ret < 0) {
3383         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3384         goto fail;
3385     }
3386
3387     check_filter_outputs();
3388
3389 fail:
3390     uninit_parse_context(&octx);
3391     if (ret < 0) {
3392         av_strerror(ret, error, sizeof(error));
3393         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3394     }
3395     return ret;
3396 }
3397
3398 static int opt_progress(void *optctx, const char *opt, const char *arg)
3399 {
3400     AVIOContext *avio = NULL;
3401     int ret;
3402
3403     if (!strcmp(arg, "-"))
3404         arg = "pipe:";
3405     ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3406     if (ret < 0) {
3407         av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3408                arg, av_err2str(ret));
3409         return ret;
3410     }
3411     progress_avio = avio;
3412     return 0;
3413 }
3414
3415 #define OFFSET(x) offsetof(OptionsContext, x)
3416 const OptionDef options[] = {
3417     /* main options */
3418     CMDUTILS_COMMON_OPTIONS
3419     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET |
3420                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(format) },
3421         "force format", "fmt" },
3422     { "y",              OPT_BOOL,                                    {              &file_overwrite },
3423         "overwrite output files" },
3424     { "n",              OPT_BOOL,                                    {              &no_file_overwrite },
3425         "never overwrite output files" },
3426     { "ignore_unknown", OPT_BOOL,                                    {              &ignore_unknown_streams },
3427         "Ignore unknown stream types" },
3428     { "copy_unknown",   OPT_BOOL | OPT_EXPERT,                       {              &copy_unknown_streams },
3429         "Copy unknown stream types" },
3430     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC |
3431                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
3432         "codec name", "codec" },
3433     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC |
3434                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
3435         "codec name", "codec" },
3436     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC |
3437                         OPT_OUTPUT,                                  { .off       = OFFSET(presets) },
3438         "preset name", "preset" },
3439     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3440                         OPT_OUTPUT,                                  { .func_arg = opt_map },
3441         "set input stream mapping",
3442         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3443     { "map_channel",    HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3444         "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3445     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC |
3446                         OPT_OUTPUT,                                  { .off       = OFFSET(metadata_map) },
3447         "set metadata information of outfile from infile",
3448         "outfile[,metadata]:infile[,metadata]" },
3449     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3450                         OPT_OUTPUT,                                  { .off = OFFSET(chapters_input_file) },
3451         "set chapters mapping", "input_file_index" },
3452     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET |
3453                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(recording_time) },
3454         "record or transcode \"duration\" seconds of audio/video",
3455         "duration" },
3456     { "to",             HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,  { .off = OFFSET(stop_time) },
3457         "record or transcode stop time", "time_stop" },
3458     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3459         "set the limit file size in bytes", "limit_size" },
3460     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET |
3461                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time) },
3462         "set the start time offset", "time_off" },
3463     { "sseof",          HAS_ARG | OPT_TIME | OPT_OFFSET |
3464                         OPT_INPUT,                                   { .off = OFFSET(start_time_eof) },
3465         "set the start time offset relative to EOF", "time_off" },
3466     { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3467                         OPT_INPUT,                                   { .off = OFFSET(seek_timestamp) },
3468         "enable/disable seeking by timestamp with -ss" },
3469     { "accurate_seek",  OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3470                         OPT_INPUT,                                   { .off = OFFSET(accurate_seek) },
3471         "enable/disable accurate seeking with -ss" },
3472     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET |
3473                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(input_ts_offset) },
3474         "set the input ts offset", "time_off" },
3475     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3476                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(ts_scale) },
3477         "set the input ts scale", "scale" },
3478     { "timestamp",      HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_recording_timestamp },
3479         "set the recording timestamp ('now' to set the current time)", "time" },
3480     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3481         "add metadata", "string=string" },
3482     { "program",        HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3483         "add program with specified streams", "title=string:st=number..." },
3484     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3485                         OPT_OUTPUT,                                  { .func_arg = opt_data_frames },
3486         "set the number of data frames to output", "number" },
3487     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
3488         "add timings for benchmarking" },
3489     { "benchmark_all",  OPT_BOOL | OPT_EXPERT,                       { &do_benchmark_all },
3490       "add timings for each task" },
3491     { "progress",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_progress },
3492       "write program-readable progress information", "url" },
3493     { "stdin",          OPT_BOOL | OPT_EXPERT,                       { &stdin_interaction },
3494       "enable or disable interaction on standard input" },
3495     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
3496         "set max runtime in seconds in CPU user time", "limit" },
3497     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
3498         "dump each input packet" },
3499     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
3500         "when dumping packets, also dump the payload" },
3501     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3502                         OPT_INPUT,                                   { .off = OFFSET(rate_emu) },
3503         "read input at native frame rate", "" },
3504     { "target",         HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_target },
3505         "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3506         "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3507     { "vsync",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_vsync },
3508         "video sync method", "" },
3509     { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,      { &frame_drop_threshold },
3510         "frame drop threshold", "" },
3511     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
3512         "audio sync method", "" },
3513     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
3514         "audio drift threshold", "threshold" },
3515     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
3516         "copy timestamps" },
3517     { "start_at_zero",  OPT_BOOL | OPT_EXPERT,                       { &start_at_zero },
3518         "shift input timestamps to start at 0 when using copyts" },
3519     { "copytb",         HAS_ARG | OPT_INT | OPT_EXPERT,              { &copy_tb },
3520         "copy input stream time base when stream copying", "mode" },
3521     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3522                         OPT_OUTPUT,                                  { .off = OFFSET(shortest) },
3523         "finish encoding within shortest input" },
3524     { "bitexact",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3525                         OPT_OUTPUT | OPT_INPUT,                      { .off = OFFSET(bitexact) },
3526         "bitexact mode" },
3527     { "apad",           OPT_STRING | HAS_ARG | OPT_SPEC |
3528                         OPT_OUTPUT,                                  { .off = OFFSET(apad) },
3529         "audio pad", "" },
3530     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
3531         "timestamp discontinuity delta threshold", "threshold" },
3532     { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_error_threshold },
3533         "timestamp error delta threshold", "threshold" },
3534     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
3535         "exit on error", "error" },
3536     { "abort_on",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_abort_on },
3537         "abort on the specified condition flags", "flags" },
3538     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3539                         OPT_OUTPUT,                                  { .off = OFFSET(copy_initial_nonkeyframes) },
3540         "copy initial non-keyframes" },
3541     { "copypriorss",    OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,   { .off = OFFSET(copy_prior_start) },
3542         "copy or discard frames before start time" },
3543     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3544         "set the number of frames to output", "number" },
3545     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC |
3546                         OPT_EXPERT | OPT_OUTPUT | OPT_INPUT,         { .off = OFFSET(codec_tags) },
3547         "force codec tag/fourcc", "fourcc/tag" },
3548     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3549                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
3550         "use fixed quality scale (VBR)", "q" },
3551     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3552                         OPT_OUTPUT,                                  { .func_arg = opt_qscale },
3553         "use fixed quality scale (VBR)", "q" },
3554     { "profile",        HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3555         "set profile", "profile" },
3556     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3557         "set stream filtergraph", "filter_graph" },
3558     { "filter_threads",  HAS_ARG | OPT_INT,                          { &filter_nbthreads },
3559         "number of non-complex filter threads" },
3560     { "filter_script",  HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3561         "read stream filtergraph description from a file", "filename" },
3562     { "reinit_filter",  HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT,    { .off = OFFSET(reinit_filters) },
3563         "reinit filtergraph on input parameter changes", "" },
3564     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
3565         "create a complex filtergraph", "graph_description" },
3566     { "filter_complex_threads", HAS_ARG | OPT_INT,                   { &filter_complex_nbthreads },
3567         "number of threads for -filter_complex" },
3568     { "lavfi",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
3569         "create a complex filtergraph", "graph_description" },
3570     { "filter_complex_script", HAS_ARG | OPT_EXPERT,                 { .func_arg = opt_filter_complex_script },
3571         "read complex filtergraph description from a file", "filename" },
3572     { "auto_conversion_filters", OPT_BOOL | OPT_EXPERT,              { &auto_conversion_filters },
3573         "enable automatic conversion filters globally" },
3574     { "stats",          OPT_BOOL,                                    { &print_stats },
3575         "print progress report during encoding", },
3576     { "stats_period",    HAS_ARG | OPT_EXPERT,                       { .func_arg = opt_stats_period },
3577         "set the period at which ffmpeg updates stats and -progress output", "time" },
3578     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3579                         OPT_OUTPUT,                                  { .func_arg = opt_attach },
3580         "add an attachment to the output file", "filename" },
3581     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3582                          OPT_EXPERT | OPT_INPUT,                     { .off = OFFSET(dump_attachment) },
3583         "extract an attachment into a file", "filename" },
3584     { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3585                         OPT_OFFSET,                                  { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3586     { "debug_ts",       OPT_BOOL | OPT_EXPERT,                       { &debug_ts },
3587         "print timestamp debugging info" },
3588     { "max_error_rate",  HAS_ARG | OPT_FLOAT,                        { &max_error_rate },
3589         "ratio of decoding errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success.", "maximum error rate" },
3590     { "discard",        OPT_STRING | HAS_ARG | OPT_SPEC |
3591                         OPT_INPUT,                                   { .off = OFFSET(discard) },
3592         "discard", "" },
3593     { "disposition",    OPT_STRING | HAS_ARG | OPT_SPEC |
3594                         OPT_OUTPUT,                                  { .off = OFFSET(disposition) },
3595         "disposition", "" },
3596     { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3597                                                                      { .off = OFFSET(thread_queue_size) },
3598         "set the maximum number of queued packets from the demuxer" },
3599     { "find_stream_info", OPT_BOOL | OPT_PERFILE | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3600         "read and decode the streams to fill missing information with heuristics" },
3601
3602     /* video options */
3603     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_frames },
3604         "set the number of video frames to output", "number" },
3605     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
3606                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_rates) },
3607         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3608     { "fpsmax",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
3609                       OPT_OUTPUT,                                                { .off = OFFSET(max_frame_rates) },
3610         "set max frame rate (Hz value, fraction or abbreviation)", "rate" },
3611     { "s",            OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3612                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_sizes) },
3613         "set frame size (WxH or abbreviation)", "size" },
3614     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
3615                       OPT_OUTPUT,                                                { .off = OFFSET(frame_aspect_ratios) },
3616         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3617     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3618                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_pix_fmts) },
3619         "set pixel format", "format" },
3620     { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG,                      { &frame_bits_per_raw_sample },
3621         "set the number of bits per raw sample", "number" },
3622     { "intra",        OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &intra_only },
3623         "deprecated use -g 1" },
3624     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3625         "disable video" },
3626     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3627                       OPT_OUTPUT,                                                { .off = OFFSET(rc_overrides) },
3628         "rate control override for specific intervals", "override" },
3629     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_INPUT |
3630                       OPT_OUTPUT,                                                { .func_arg = opt_video_codec },
3631         "force video codec ('copy' to copy stream)", "codec" },
3632     { "sameq",        OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
3633         "Removed" },
3634     { "same_quant",   OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
3635         "Removed" },
3636     { "timecode",     OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_timecode },
3637         "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3638     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT,     { .off = OFFSET(pass) },
3639         "select the pass number (1 to 3)", "n" },
3640     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3641                       OPT_OUTPUT,                                                { .off = OFFSET(passlogfiles) },
3642         "select two pass log file name prefix", "prefix" },
3643     { "deinterlace",  OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_deinterlace },
3644         "this option is deprecated, use the yadif filter instead" },
3645     { "psnr",         OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_psnr },
3646         "calculate PSNR of compressed frames" },
3647     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_vstats },
3648         "dump video coding statistics to file" },
3649     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { .func_arg = opt_vstats_file },
3650         "dump video coding statistics to file", "file" },
3651     { "vstats_version",  OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,            { &vstats_version },
3652         "Version of the vstats format to use."},
3653     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_filters },
3654         "set video filters", "filter_graph" },
3655     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3656                       OPT_OUTPUT,                                                { .off = OFFSET(intra_matrices) },
3657         "specify intra matrix coeffs", "matrix" },
3658     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3659                       OPT_OUTPUT,                                                { .off = OFFSET(inter_matrices) },
3660         "specify inter matrix coeffs", "matrix" },
3661     { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3662                       OPT_OUTPUT,                                                { .off = OFFSET(chroma_intra_matrices) },
3663         "specify intra matrix coeffs", "matrix" },
3664     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC |
3665                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(top_field_first) },
3666         "top=1/bottom=0/auto=-1 field first", "" },
3667     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE |
3668                       OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_old2new },
3669         "force video tag/fourcc", "fourcc/tag" },
3670     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
3671         "show QP histogram" },
3672     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC |
3673                       OPT_OUTPUT,                                                { .off = OFFSET(force_fps) },
3674         "force the selected framerate, disable the best supported framerate selection" },
3675     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3676                       OPT_OUTPUT,                                                { .func_arg = opt_streamid },
3677         "set the value of an outfile streamid", "streamIndex:value" },
3678     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3679                           OPT_SPEC | OPT_OUTPUT,                                 { .off = OFFSET(forced_key_frames) },
3680         "force key frames at specified timestamps", "timestamps" },
3681     { "ab",           OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
3682         "audio bitrate (please use -b:a)", "bitrate" },
3683     { "b",            OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
3684         "video bitrate (please use -b:v)", "bitrate" },
3685     { "hwaccel",          OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3686                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccels) },
3687         "use HW accelerated decoding", "hwaccel name" },
3688     { "hwaccel_device",   OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3689                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_devices) },
3690         "select a device for HW acceleration", "devicename" },
3691     { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3692                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_output_formats) },
3693         "select output format used with HW accelerated decoding", "format" },
3694 #if CONFIG_VIDEOTOOLBOX
3695     { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3696 #endif
3697     { "hwaccels",         OPT_EXIT,                                              { .func_arg = show_hwaccels },
3698         "show available HW acceleration methods" },
3699     { "autorotate",       HAS_ARG | OPT_BOOL | OPT_SPEC |
3700                           OPT_EXPERT | OPT_INPUT,                                { .off = OFFSET(autorotate) },
3701         "automatically insert correct rotate filters" },
3702     { "autoscale",        HAS_ARG | OPT_BOOL | OPT_SPEC |
3703                           OPT_EXPERT | OPT_OUTPUT,                               { .off = OFFSET(autoscale) },
3704         "automatically insert a scale filter at the end of the filter graph" },
3705
3706     /* audio options */
3707     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_frames },
3708         "set the number of audio frames to output", "number" },
3709     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_qscale },
3710         "set audio quality (codec-specific)", "quality", },
3711     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
3712                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_sample_rate) },
3713         "set audio sampling rate (in Hz)", "rate" },
3714     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
3715                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_channels) },
3716         "set number of audio channels", "channels" },
3717     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3718         "disable audio" },
3719     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE |
3720                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_audio_codec },
3721         "force audio codec ('copy' to copy stream)", "codec" },
3722     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
3723                         OPT_OUTPUT,                                                { .func_arg = opt_old2new },
3724         "force audio tag/fourcc", "fourcc/tag" },
3725     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
3726         "change audio volume (256=normal)" , "volume" },
3727     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC |
3728                         OPT_STRING | OPT_INPUT | OPT_OUTPUT,                       { .off = OFFSET(sample_fmts) },
3729         "set sample format", "format" },
3730     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
3731                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_channel_layout },
3732         "set channel layout", "layout" },
3733     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_filters },
3734         "set audio filters", "filter_graph" },
3735     { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3736       "set the maximum number of channels to try to guess the channel layout" },
3737
3738     /* subtitle options */
3739     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3740         "disable subtitle" },
3741     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3742         "force subtitle codec ('copy' to copy stream)", "codec" },
3743     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3744         , "force subtitle tag/fourcc", "fourcc/tag" },
3745     { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3746         "fix subtitles duration" },
3747     { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3748         "set canvas size (WxH or abbreviation)", "size" },
3749
3750     /* grab options */
3751     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3752         "deprecated, use -channel", "channel" },
3753     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3754         "deprecated, use -standard", "standard" },
3755     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3756
3757     /* muxer options */
3758     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3759         "set the maximum demux-decode delay", "seconds" },
3760     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3761         "set the initial demux-decode delay", "seconds" },
3762     { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3763         "specify a file in which to print sdp information", "file" },
3764
3765     { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3766         "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3767     { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) },
3768         "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
3769         "two special values are defined - "
3770         "0 = use frame rate (video) or sample rate (audio),"
3771         "-1 = match source time base", "ratio" },
3772
3773     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3774         "A comma-separated list of bitstream filters", "bitstream_filters" },
3775     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3776         "deprecated", "audio bitstream_filters" },
3777     { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3778         "deprecated", "video bitstream_filters" },
3779
3780     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
3781         "set the audio options to the indicated preset", "preset" },
3782     { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
3783         "set the video options to the indicated preset", "preset" },
3784     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3785         "set the subtitle options to the indicated preset", "preset" },
3786     { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,                { .func_arg = opt_preset },
3787         "set options from indicated preset file", "filename" },
3788
3789     { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3790         "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3791     { "muxing_queue_data_threshold", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(muxing_queue_data_threshold) },
3792         "set the threshold after which max_muxing_queue_size is taken into account", "bytes" },
3793
3794     /* data codec support */
3795     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3796         "force data codec ('copy' to copy stream)", "codec" },
3797     { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3798         "disable data" },
3799
3800 #if CONFIG_VAAPI
3801     { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3802         "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3803 #endif
3804
3805 #if CONFIG_QSV
3806     { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3807         "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
3808 #endif
3809
3810     { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
3811         "initialise hardware device", "args" },
3812     { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
3813         "set hardware device used when filtering", "device" },
3814
3815     { NULL, },
3816 };