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 FF_API_LAVF_AVCTX
2446     for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2447         AVDictionaryEntry *e;
2448         ost = output_streams[i];
2449
2450         if ((ost->stream_copy || ost->attachment_filename)
2451             && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2452             && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2453             if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2454                 exit_program(1);
2455     }
2456 #endif
2457
2458     if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2459         av_dump_format(oc, nb_output_files - 1, oc->url, 1);
2460         av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2461         exit_program(1);
2462     }
2463
2464     /* check if all codec options have been used */
2465     unused_opts = strip_specifiers(o->g->codec_opts);
2466     for (i = of->ost_index; i < nb_output_streams; i++) {
2467         e = NULL;
2468         while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2469                                 AV_DICT_IGNORE_SUFFIX)))
2470             av_dict_set(&unused_opts, e->key, NULL, 0);
2471     }
2472
2473     e = NULL;
2474     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2475         const AVClass *class = avcodec_get_class();
2476         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2477                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2478         const AVClass *fclass = avformat_get_class();
2479         const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2480                                               AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2481         if (!option || foption)
2482             continue;
2483
2484
2485         if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2486             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2487                    "output file #%d (%s) is not an encoding option.\n", e->key,
2488                    option->help ? option->help : "", nb_output_files - 1,
2489                    filename);
2490             exit_program(1);
2491         }
2492
2493         // gop_timecode is injected by generic code but not always used
2494         if (!strcmp(e->key, "gop_timecode"))
2495             continue;
2496
2497         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2498                "output file #%d (%s) has not been used for any stream. The most "
2499                "likely reason is either wrong type (e.g. a video option with "
2500                "no video streams) or that it is a private option of some encoder "
2501                "which was not actually used for any stream.\n", e->key,
2502                option->help ? option->help : "", nb_output_files - 1, filename);
2503     }
2504     av_dict_free(&unused_opts);
2505
2506     /* set the decoding_needed flags and create simple filtergraphs */
2507     for (i = of->ost_index; i < nb_output_streams; i++) {
2508         OutputStream *ost = output_streams[i];
2509
2510         if (ost->encoding_needed && ost->source_index >= 0) {
2511             InputStream *ist = input_streams[ost->source_index];
2512             ist->decoding_needed |= DECODING_FOR_OST;
2513
2514             if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2515                 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2516                 err = init_simple_filtergraph(ist, ost);
2517                 if (err < 0) {
2518                     av_log(NULL, AV_LOG_ERROR,
2519                            "Error initializing a simple filtergraph between streams "
2520                            "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2521                            nb_output_files - 1, ost->st->index);
2522                     exit_program(1);
2523                 }
2524             }
2525         }
2526
2527         /* set the filter output constraints */
2528         if (ost->filter) {
2529             OutputFilter *f = ost->filter;
2530             int count;
2531             switch (ost->enc_ctx->codec_type) {
2532             case AVMEDIA_TYPE_VIDEO:
2533                 f->frame_rate = ost->frame_rate;
2534                 f->width      = ost->enc_ctx->width;
2535                 f->height     = ost->enc_ctx->height;
2536                 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2537                     f->format = ost->enc_ctx->pix_fmt;
2538                 } else if (ost->enc->pix_fmts) {
2539                     count = 0;
2540                     while (ost->enc->pix_fmts[count] != AV_PIX_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->pix_fmts, (count + 1) * sizeof(*f->formats));
2546                 }
2547                 break;
2548             case AVMEDIA_TYPE_AUDIO:
2549                 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2550                     f->format = ost->enc_ctx->sample_fmt;
2551                 } else if (ost->enc->sample_fmts) {
2552                     count = 0;
2553                     while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2554                         count++;
2555                     f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2556                     if (!f->formats)
2557                         exit_program(1);
2558                     memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2559                 }
2560                 if (ost->enc_ctx->sample_rate) {
2561                     f->sample_rate = ost->enc_ctx->sample_rate;
2562                 } else if (ost->enc->supported_samplerates) {
2563                     count = 0;
2564                     while (ost->enc->supported_samplerates[count])
2565                         count++;
2566                     f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2567                     if (!f->sample_rates)
2568                         exit_program(1);
2569                     memcpy(f->sample_rates, ost->enc->supported_samplerates,
2570                            (count + 1) * sizeof(*f->sample_rates));
2571                 }
2572                 if (ost->enc_ctx->channels) {
2573                     f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2574                 } else if (ost->enc->channel_layouts) {
2575                     count = 0;
2576                     while (ost->enc->channel_layouts[count])
2577                         count++;
2578                     f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2579                     if (!f->channel_layouts)
2580                         exit_program(1);
2581                     memcpy(f->channel_layouts, ost->enc->channel_layouts,
2582                            (count + 1) * sizeof(*f->channel_layouts));
2583                 }
2584                 break;
2585             }
2586         }
2587     }
2588
2589     /* check filename in case of an image number is expected */
2590     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2591         if (!av_filename_number_test(oc->url)) {
2592             print_error(oc->url, AVERROR(EINVAL));
2593             exit_program(1);
2594         }
2595     }
2596
2597     if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2598         av_log(NULL, AV_LOG_ERROR,
2599                "No input streams but output needs an input stream\n");
2600         exit_program(1);
2601     }
2602
2603     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2604         /* test if it already exists to avoid losing precious files */
2605         assert_file_overwrite(filename);
2606
2607         /* open the file */
2608         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2609                               &oc->interrupt_callback,
2610                               &of->opts)) < 0) {
2611             print_error(filename, err);
2612             exit_program(1);
2613         }
2614     } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2615         assert_file_overwrite(filename);
2616
2617     if (o->mux_preload) {
2618         av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2619     }
2620     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2621
2622     /* copy metadata */
2623     for (i = 0; i < o->nb_metadata_map; i++) {
2624         char *p;
2625         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2626
2627         if (in_file_index >= nb_input_files) {
2628             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2629             exit_program(1);
2630         }
2631         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2632                       in_file_index >= 0 ?
2633                       input_files[in_file_index]->ctx : NULL, o);
2634     }
2635
2636     /* copy chapters */
2637     if (o->chapters_input_file >= nb_input_files) {
2638         if (o->chapters_input_file == INT_MAX) {
2639             /* copy chapters from the first input file that has them*/
2640             o->chapters_input_file = -1;
2641             for (i = 0; i < nb_input_files; i++)
2642                 if (input_files[i]->ctx->nb_chapters) {
2643                     o->chapters_input_file = i;
2644                     break;
2645                 }
2646         } else {
2647             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2648                    o->chapters_input_file);
2649             exit_program(1);
2650         }
2651     }
2652     if (o->chapters_input_file >= 0)
2653         copy_chapters(input_files[o->chapters_input_file], of,
2654                       !o->metadata_chapters_manual);
2655
2656     /* copy global metadata by default */
2657     if (!o->metadata_global_manual && nb_input_files){
2658         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2659                      AV_DICT_DONT_OVERWRITE);
2660         if(o->recording_time != INT64_MAX)
2661             av_dict_set(&oc->metadata, "duration", NULL, 0);
2662         av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2663         av_dict_set(&oc->metadata, "company_name", NULL, 0);
2664         av_dict_set(&oc->metadata, "product_name", NULL, 0);
2665         av_dict_set(&oc->metadata, "product_version", NULL, 0);
2666     }
2667     if (!o->metadata_streams_manual)
2668         for (i = of->ost_index; i < nb_output_streams; i++) {
2669             InputStream *ist;
2670             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
2671                 continue;
2672             ist = input_streams[output_streams[i]->source_index];
2673             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2674             if (!output_streams[i]->stream_copy) {
2675                 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2676             }
2677         }
2678
2679     /* process manually set programs */
2680     for (i = 0; i < o->nb_program; i++) {
2681         const char *p = o->program[i].u.str;
2682         int progid = i+1;
2683         AVProgram *program;
2684
2685         while(*p) {
2686             const char *p2 = av_get_token(&p, ":");
2687             const char *to_dealloc = p2;
2688             char *key;
2689             if (!p2)
2690                 break;
2691
2692             if(*p) p++;
2693
2694             key = av_get_token(&p2, "=");
2695             if (!key || !*p2) {
2696                 av_freep(&to_dealloc);
2697                 av_freep(&key);
2698                 break;
2699             }
2700             p2++;
2701
2702             if (!strcmp(key, "program_num"))
2703                 progid = strtol(p2, NULL, 0);
2704             av_freep(&to_dealloc);
2705             av_freep(&key);
2706         }
2707
2708         program = av_new_program(oc, progid);
2709
2710         p = o->program[i].u.str;
2711         while(*p) {
2712             const char *p2 = av_get_token(&p, ":");
2713             const char *to_dealloc = p2;
2714             char *key;
2715             if (!p2)
2716                 break;
2717             if(*p) p++;
2718
2719             key = av_get_token(&p2, "=");
2720             if (!key) {
2721                 av_log(NULL, AV_LOG_FATAL,
2722                        "No '=' character in program string %s.\n",
2723                        p2);
2724                 exit_program(1);
2725             }
2726             if (!*p2)
2727                 exit_program(1);
2728             p2++;
2729
2730             if (!strcmp(key, "title")) {
2731                 av_dict_set(&program->metadata, "title", p2, 0);
2732             } else if (!strcmp(key, "program_num")) {
2733             } else if (!strcmp(key, "st")) {
2734                 int st_num = strtol(p2, NULL, 0);
2735                 av_program_add_stream_index(oc, progid, st_num);
2736             } else {
2737                 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2738                 exit_program(1);
2739             }
2740             av_freep(&to_dealloc);
2741             av_freep(&key);
2742         }
2743     }
2744
2745     /* process manually set metadata */
2746     for (i = 0; i < o->nb_metadata; i++) {
2747         AVDictionary **m;
2748         char type, *val;
2749         const char *stream_spec;
2750         int index = 0, j, ret = 0;
2751
2752         val = strchr(o->metadata[i].u.str, '=');
2753         if (!val) {
2754             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2755                    o->metadata[i].u.str);
2756             exit_program(1);
2757         }
2758         *val++ = 0;
2759
2760         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2761         if (type == 's') {
2762             for (j = 0; j < oc->nb_streams; j++) {
2763                 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2764                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2765                     if (!strcmp(o->metadata[i].u.str, "rotate")) {
2766                         char *tail;
2767                         double theta = av_strtod(val, &tail);
2768                         if (!*tail) {
2769                             ost->rotate_overridden = 1;
2770                             ost->rotate_override_value = theta;
2771                         }
2772                     } else {
2773                         av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2774                     }
2775                 } else if (ret < 0)
2776                     exit_program(1);
2777             }
2778         }
2779         else {
2780             switch (type) {
2781             case 'g':
2782                 m = &oc->metadata;
2783                 break;
2784             case 'c':
2785                 if (index < 0 || index >= oc->nb_chapters) {
2786                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2787                     exit_program(1);
2788                 }
2789                 m = &oc->chapters[index]->metadata;
2790                 break;
2791             case 'p':
2792                 if (index < 0 || index >= oc->nb_programs) {
2793                     av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2794                     exit_program(1);
2795                 }
2796                 m = &oc->programs[index]->metadata;
2797                 break;
2798             default:
2799                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2800                 exit_program(1);
2801             }
2802             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2803         }
2804     }
2805
2806     return 0;
2807 }
2808
2809 static int opt_target(void *optctx, const char *opt, const char *arg)
2810 {
2811     OptionsContext *o = optctx;
2812     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2813     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2814
2815     if (!strncmp(arg, "pal-", 4)) {
2816         norm = PAL;
2817         arg += 4;
2818     } else if (!strncmp(arg, "ntsc-", 5)) {
2819         norm = NTSC;
2820         arg += 5;
2821     } else if (!strncmp(arg, "film-", 5)) {
2822         norm = FILM;
2823         arg += 5;
2824     } else {
2825         /* Try to determine PAL/NTSC by peeking in the input files */
2826         if (nb_input_files) {
2827             int i, j;
2828             for (j = 0; j < nb_input_files; j++) {
2829                 for (i = 0; i < input_files[j]->nb_streams; i++) {
2830                     AVStream *st = input_files[j]->ctx->streams[i];
2831                     int64_t fr;
2832                     if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2833                         continue;
2834                     fr = st->time_base.den * 1000LL / st->time_base.num;
2835                     if (fr == 25000) {
2836                         norm = PAL;
2837                         break;
2838                     } else if ((fr == 29970) || (fr == 23976)) {
2839                         norm = NTSC;
2840                         break;
2841                     }
2842                 }
2843                 if (norm != UNKNOWN)
2844                     break;
2845             }
2846         }
2847         if (norm != UNKNOWN)
2848             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2849     }
2850
2851     if (norm == UNKNOWN) {
2852         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2853         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2854         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2855         exit_program(1);
2856     }
2857
2858     if (!strcmp(arg, "vcd")) {
2859         opt_video_codec(o, "c:v", "mpeg1video");
2860         opt_audio_codec(o, "c:a", "mp2");
2861         parse_option(o, "f", "vcd", options);
2862
2863         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2864         parse_option(o, "r", frame_rates[norm], options);
2865         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2866
2867         opt_default(NULL, "b:v", "1150000");
2868         opt_default(NULL, "maxrate:v", "1150000");
2869         opt_default(NULL, "minrate:v", "1150000");
2870         opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2871
2872         opt_default(NULL, "b:a", "224000");
2873         parse_option(o, "ar", "44100", options);
2874         parse_option(o, "ac", "2", options);
2875
2876         opt_default(NULL, "packetsize", "2324");
2877         opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2878
2879         /* We have to offset the PTS, so that it is consistent with the SCR.
2880            SCR starts at 36000, but the first two packs contain only padding
2881            and the first pack from the other stream, respectively, may also have
2882            been written before.
2883            So the real data starts at SCR 36000+3*1200. */
2884         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2885     } else if (!strcmp(arg, "svcd")) {
2886
2887         opt_video_codec(o, "c:v", "mpeg2video");
2888         opt_audio_codec(o, "c:a", "mp2");
2889         parse_option(o, "f", "svcd", options);
2890
2891         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2892         parse_option(o, "r", frame_rates[norm], options);
2893         parse_option(o, "pix_fmt", "yuv420p", options);
2894         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2895
2896         opt_default(NULL, "b:v", "2040000");
2897         opt_default(NULL, "maxrate:v", "2516000");
2898         opt_default(NULL, "minrate:v", "0"); // 1145000;
2899         opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2900         opt_default(NULL, "scan_offset", "1");
2901
2902         opt_default(NULL, "b:a", "224000");
2903         parse_option(o, "ar", "44100", options);
2904
2905         opt_default(NULL, "packetsize", "2324");
2906
2907     } else if (!strcmp(arg, "dvd")) {
2908
2909         opt_video_codec(o, "c:v", "mpeg2video");
2910         opt_audio_codec(o, "c:a", "ac3");
2911         parse_option(o, "f", "dvd", options);
2912
2913         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2914         parse_option(o, "r", frame_rates[norm], options);
2915         parse_option(o, "pix_fmt", "yuv420p", options);
2916         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2917
2918         opt_default(NULL, "b:v", "6000000");
2919         opt_default(NULL, "maxrate:v", "9000000");
2920         opt_default(NULL, "minrate:v", "0"); // 1500000;
2921         opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2922
2923         opt_default(NULL, "packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2924         opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2925
2926         opt_default(NULL, "b:a", "448000");
2927         parse_option(o, "ar", "48000", options);
2928
2929     } else if (!strncmp(arg, "dv", 2)) {
2930
2931         parse_option(o, "f", "dv", options);
2932
2933         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2934         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2935                           norm == PAL ? "yuv420p" : "yuv411p", options);
2936         parse_option(o, "r", frame_rates[norm], options);
2937
2938         parse_option(o, "ar", "48000", options);
2939         parse_option(o, "ac", "2", options);
2940
2941     } else {
2942         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2943         return AVERROR(EINVAL);
2944     }
2945
2946     av_dict_copy(&o->g->codec_opts,  codec_opts, AV_DICT_DONT_OVERWRITE);
2947     av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2948
2949     return 0;
2950 }
2951
2952 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2953 {
2954     av_free (vstats_filename);
2955     vstats_filename = av_strdup (arg);
2956     return 0;
2957 }
2958
2959 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2960 {
2961     char filename[40];
2962     time_t today2 = time(NULL);
2963     struct tm *today = localtime(&today2);
2964
2965     if (!today) { // maybe tomorrow
2966         av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2967         exit_program(1);
2968     }
2969
2970     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2971              today->tm_sec);
2972     return opt_vstats_file(NULL, opt, filename);
2973 }
2974
2975 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2976 {
2977     OptionsContext *o = optctx;
2978     return parse_option(o, "frames:v", arg, options);
2979 }
2980
2981 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2982 {
2983     OptionsContext *o = optctx;
2984     return parse_option(o, "frames:a", arg, options);
2985 }
2986
2987 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2988 {
2989     OptionsContext *o = optctx;
2990     return parse_option(o, "frames:d", arg, options);
2991 }
2992
2993 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2994 {
2995     int ret;
2996     AVDictionary *cbak = codec_opts;
2997     AVDictionary *fbak = format_opts;
2998     codec_opts = NULL;
2999     format_opts = NULL;
3000
3001     ret = opt_default(NULL, opt, arg);
3002
3003     av_dict_copy(&o->g->codec_opts , codec_opts, 0);
3004     av_dict_copy(&o->g->format_opts, format_opts, 0);
3005     av_dict_free(&codec_opts);
3006     av_dict_free(&format_opts);
3007     codec_opts = cbak;
3008     format_opts = fbak;
3009
3010     return ret;
3011 }
3012
3013 static int opt_preset(void *optctx, const char *opt, const char *arg)
3014 {
3015     OptionsContext *o = optctx;
3016     FILE *f=NULL;
3017     char filename[1000], line[1000], tmp_line[1000];
3018     const char *codec_name = NULL;
3019
3020     tmp_line[0] = *opt;
3021     tmp_line[1] = 0;
3022     MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
3023
3024     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
3025         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
3026             av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
3027         }else
3028             av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
3029         exit_program(1);
3030     }
3031
3032     while (fgets(line, sizeof(line), f)) {
3033         char *key = tmp_line, *value, *endptr;
3034
3035         if (strcspn(line, "#\n\r") == 0)
3036             continue;
3037         av_strlcpy(tmp_line, line, sizeof(tmp_line));
3038         if (!av_strtok(key,   "=",    &value) ||
3039             !av_strtok(value, "\r\n", &endptr)) {
3040             av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
3041             exit_program(1);
3042         }
3043         av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
3044
3045         if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
3046         else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
3047         else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
3048         else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
3049         else if (opt_default_new(o, key, value) < 0) {
3050             av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
3051                    filename, line, key, value);
3052             exit_program(1);
3053         }
3054     }
3055
3056     fclose(f);
3057
3058     return 0;
3059 }
3060
3061 static int opt_old2new(void *optctx, const char *opt, const char *arg)
3062 {
3063     OptionsContext *o = optctx;
3064     int ret;
3065     char *s = av_asprintf("%s:%c", opt + 1, *opt);
3066     if (!s)
3067         return AVERROR(ENOMEM);
3068     ret = parse_option(o, s, arg, options);
3069     av_free(s);
3070     return ret;
3071 }
3072
3073 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
3074 {
3075     OptionsContext *o = optctx;
3076
3077     if(!strcmp(opt, "ab")){
3078         av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
3079         return 0;
3080     } else if(!strcmp(opt, "b")){
3081         av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
3082         av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
3083         return 0;
3084     }
3085     av_dict_set(&o->g->codec_opts, opt, arg, 0);
3086     return 0;
3087 }
3088
3089 static int opt_qscale(void *optctx, const char *opt, const char *arg)
3090 {
3091     OptionsContext *o = optctx;
3092     char *s;
3093     int ret;
3094     if(!strcmp(opt, "qscale")){
3095         av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
3096         return parse_option(o, "q:v", arg, options);
3097     }
3098     s = av_asprintf("q%s", opt + 6);
3099     if (!s)
3100         return AVERROR(ENOMEM);
3101     ret = parse_option(o, s, arg, options);
3102     av_free(s);
3103     return ret;
3104 }
3105
3106 static int opt_profile(void *optctx, const char *opt, const char *arg)
3107 {
3108     OptionsContext *o = optctx;
3109     if(!strcmp(opt, "profile")){
3110         av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
3111         av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
3112         return 0;
3113     }
3114     av_dict_set(&o->g->codec_opts, opt, arg, 0);
3115     return 0;
3116 }
3117
3118 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3119 {
3120     OptionsContext *o = optctx;
3121     return parse_option(o, "filter:v", arg, options);
3122 }
3123
3124 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3125 {
3126     OptionsContext *o = optctx;
3127     return parse_option(o, "filter:a", arg, options);
3128 }
3129
3130 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3131 {
3132     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
3133     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
3134     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3135     else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
3136
3137     if (video_sync_method == VSYNC_AUTO)
3138         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
3139     return 0;
3140 }
3141
3142 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3143 {
3144     OptionsContext *o = optctx;
3145     int ret;
3146     char *tcr = av_asprintf("timecode=%s", arg);
3147     if (!tcr)
3148         return AVERROR(ENOMEM);
3149     ret = parse_option(o, "metadata:g", tcr, options);
3150     if (ret >= 0)
3151         ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3152     av_free(tcr);
3153     return ret;
3154 }
3155
3156 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3157 {
3158     OptionsContext *o = optctx;
3159     char layout_str[32];
3160     char *stream_str;
3161     char *ac_str;
3162     int ret, channels, ac_str_size;
3163     uint64_t layout;
3164
3165     layout = av_get_channel_layout(arg);
3166     if (!layout) {
3167         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3168         return AVERROR(EINVAL);
3169     }
3170     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3171     ret = opt_default_new(o, opt, layout_str);
3172     if (ret < 0)
3173         return ret;
3174
3175     /* set 'ac' option based on channel layout */
3176     channels = av_get_channel_layout_nb_channels(layout);
3177     snprintf(layout_str, sizeof(layout_str), "%d", channels);
3178     stream_str = strchr(opt, ':');
3179     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3180     ac_str = av_mallocz(ac_str_size);
3181     if (!ac_str)
3182         return AVERROR(ENOMEM);
3183     av_strlcpy(ac_str, "ac", 3);
3184     if (stream_str)
3185         av_strlcat(ac_str, stream_str, ac_str_size);
3186     ret = parse_option(o, ac_str, layout_str, options);
3187     av_free(ac_str);
3188
3189     return ret;
3190 }
3191
3192 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3193 {
3194     OptionsContext *o = optctx;
3195     return parse_option(o, "q:a", arg, options);
3196 }
3197
3198 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3199 {
3200     GROW_ARRAY(filtergraphs, nb_filtergraphs);
3201     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3202         return AVERROR(ENOMEM);
3203     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
3204     filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
3205     if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3206         return AVERROR(ENOMEM);
3207
3208     input_stream_potentially_available = 1;
3209
3210     return 0;
3211 }
3212
3213 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3214 {
3215     uint8_t *graph_desc = read_file(arg);
3216     if (!graph_desc)
3217         return AVERROR(EINVAL);
3218
3219     GROW_ARRAY(filtergraphs, nb_filtergraphs);
3220     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3221         return AVERROR(ENOMEM);
3222     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
3223     filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3224
3225     input_stream_potentially_available = 1;
3226
3227     return 0;
3228 }
3229
3230 void show_help_default(const char *opt, const char *arg)
3231 {
3232     /* per-file options have at least one of those set */
3233     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3234     int show_advanced = 0, show_avoptions = 0;
3235
3236     if (opt && *opt) {
3237         if (!strcmp(opt, "long"))
3238             show_advanced = 1;
3239         else if (!strcmp(opt, "full"))
3240             show_advanced = show_avoptions = 1;
3241         else
3242             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3243     }
3244
3245     show_usage();
3246
3247     printf("Getting help:\n"
3248            "    -h      -- print basic options\n"
3249            "    -h long -- print more options\n"
3250            "    -h full -- print all options (including all format and codec specific options, very long)\n"
3251            "    -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter/bsf/protocol\n"
3252            "    See man %s for detailed description of the options.\n"
3253            "\n", program_name);
3254
3255     show_help_options(options, "Print help / information / capabilities:",
3256                       OPT_EXIT, 0, 0);
3257
3258     show_help_options(options, "Global options (affect whole program "
3259                       "instead of just one file):",
3260                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3261     if (show_advanced)
3262         show_help_options(options, "Advanced global options:", OPT_EXPERT,
3263                           per_file | OPT_EXIT, 0);
3264
3265     show_help_options(options, "Per-file main options:", 0,
3266                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3267                       OPT_EXIT, per_file);
3268     if (show_advanced)
3269         show_help_options(options, "Advanced per-file options:",
3270                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3271
3272     show_help_options(options, "Video options:",
3273                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3274     if (show_advanced)
3275         show_help_options(options, "Advanced Video options:",
3276                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3277
3278     show_help_options(options, "Audio options:",
3279                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3280     if (show_advanced)
3281         show_help_options(options, "Advanced Audio options:",
3282                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3283     show_help_options(options, "Subtitle options:",
3284                       OPT_SUBTITLE, 0, 0);
3285     printf("\n");
3286
3287     if (show_avoptions) {
3288         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3289         show_help_children(avcodec_get_class(), flags);
3290         show_help_children(avformat_get_class(), flags);
3291 #if CONFIG_SWSCALE
3292         show_help_children(sws_get_class(), flags);
3293 #endif
3294 #if CONFIG_SWRESAMPLE
3295         show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3296 #endif
3297         show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3298         show_help_children(av_bsf_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_BSF_PARAM);
3299     }
3300 }
3301
3302 void show_usage(void)
3303 {
3304     av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3305     av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3306     av_log(NULL, AV_LOG_INFO, "\n");
3307 }
3308
3309 enum OptGroup {
3310     GROUP_OUTFILE,
3311     GROUP_INFILE,
3312 };
3313
3314 static const OptionGroupDef groups[] = {
3315     [GROUP_OUTFILE] = { "output url",  NULL, OPT_OUTPUT },
3316     [GROUP_INFILE]  = { "input url",   "i",  OPT_INPUT },
3317 };
3318
3319 static int open_files(OptionGroupList *l, const char *inout,
3320                       int (*open_file)(OptionsContext*, const char*))
3321 {
3322     int i, ret;
3323
3324     for (i = 0; i < l->nb_groups; i++) {
3325         OptionGroup *g = &l->groups[i];
3326         OptionsContext o;
3327
3328         init_options(&o);
3329         o.g = g;
3330
3331         ret = parse_optgroup(&o, g);
3332         if (ret < 0) {
3333             av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3334                    "%s.\n", inout, g->arg);
3335             uninit_options(&o);
3336             return ret;
3337         }
3338
3339         av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3340         ret = open_file(&o, g->arg);
3341         uninit_options(&o);
3342         if (ret < 0) {
3343             av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3344                    inout, g->arg);
3345             return ret;
3346         }
3347         av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3348     }
3349
3350     return 0;
3351 }
3352
3353 int ffmpeg_parse_options(int argc, char **argv)
3354 {
3355     OptionParseContext octx;
3356     uint8_t error[128];
3357     int ret;
3358
3359     memset(&octx, 0, sizeof(octx));
3360
3361     /* split the commandline into an internal representation */
3362     ret = split_commandline(&octx, argc, argv, options, groups,
3363                             FF_ARRAY_ELEMS(groups));
3364     if (ret < 0) {
3365         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3366         goto fail;
3367     }
3368
3369     /* apply global options */
3370     ret = parse_optgroup(NULL, &octx.global_opts);
3371     if (ret < 0) {
3372         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3373         goto fail;
3374     }
3375
3376     /* configure terminal and setup signal handlers */
3377     term_init();
3378
3379     /* open input files */
3380     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3381     if (ret < 0) {
3382         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3383         goto fail;
3384     }
3385
3386     /* create the complex filtergraphs */
3387     ret = init_complex_filters();
3388     if (ret < 0) {
3389         av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3390         goto fail;
3391     }
3392
3393     /* open output files */
3394     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3395     if (ret < 0) {
3396         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3397         goto fail;
3398     }
3399
3400     check_filter_outputs();
3401
3402 fail:
3403     uninit_parse_context(&octx);
3404     if (ret < 0) {
3405         av_strerror(ret, error, sizeof(error));
3406         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3407     }
3408     return ret;
3409 }
3410
3411 static int opt_progress(void *optctx, const char *opt, const char *arg)
3412 {
3413     AVIOContext *avio = NULL;
3414     int ret;
3415
3416     if (!strcmp(arg, "-"))
3417         arg = "pipe:";
3418     ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3419     if (ret < 0) {
3420         av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3421                arg, av_err2str(ret));
3422         return ret;
3423     }
3424     progress_avio = avio;
3425     return 0;
3426 }
3427
3428 #define OFFSET(x) offsetof(OptionsContext, x)
3429 const OptionDef options[] = {
3430     /* main options */
3431     CMDUTILS_COMMON_OPTIONS
3432     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET |
3433                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(format) },
3434         "force format", "fmt" },
3435     { "y",              OPT_BOOL,                                    {              &file_overwrite },
3436         "overwrite output files" },
3437     { "n",              OPT_BOOL,                                    {              &no_file_overwrite },
3438         "never overwrite output files" },
3439     { "ignore_unknown", OPT_BOOL,                                    {              &ignore_unknown_streams },
3440         "Ignore unknown stream types" },
3441     { "copy_unknown",   OPT_BOOL | OPT_EXPERT,                       {              &copy_unknown_streams },
3442         "Copy unknown stream types" },
3443     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC |
3444                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
3445         "codec name", "codec" },
3446     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC |
3447                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
3448         "codec name", "codec" },
3449     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC |
3450                         OPT_OUTPUT,                                  { .off       = OFFSET(presets) },
3451         "preset name", "preset" },
3452     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3453                         OPT_OUTPUT,                                  { .func_arg = opt_map },
3454         "set input stream mapping",
3455         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3456     { "map_channel",    HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3457         "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3458     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC |
3459                         OPT_OUTPUT,                                  { .off       = OFFSET(metadata_map) },
3460         "set metadata information of outfile from infile",
3461         "outfile[,metadata]:infile[,metadata]" },
3462     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3463                         OPT_OUTPUT,                                  { .off = OFFSET(chapters_input_file) },
3464         "set chapters mapping", "input_file_index" },
3465     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET |
3466                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(recording_time) },
3467         "record or transcode \"duration\" seconds of audio/video",
3468         "duration" },
3469     { "to",             HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,  { .off = OFFSET(stop_time) },
3470         "record or transcode stop time", "time_stop" },
3471     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3472         "set the limit file size in bytes", "limit_size" },
3473     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET |
3474                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time) },
3475         "set the start time offset", "time_off" },
3476     { "sseof",          HAS_ARG | OPT_TIME | OPT_OFFSET |
3477                         OPT_INPUT,                                   { .off = OFFSET(start_time_eof) },
3478         "set the start time offset relative to EOF", "time_off" },
3479     { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3480                         OPT_INPUT,                                   { .off = OFFSET(seek_timestamp) },
3481         "enable/disable seeking by timestamp with -ss" },
3482     { "accurate_seek",  OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3483                         OPT_INPUT,                                   { .off = OFFSET(accurate_seek) },
3484         "enable/disable accurate seeking with -ss" },
3485     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET |
3486                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(input_ts_offset) },
3487         "set the input ts offset", "time_off" },
3488     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3489                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(ts_scale) },
3490         "set the input ts scale", "scale" },
3491     { "timestamp",      HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_recording_timestamp },
3492         "set the recording timestamp ('now' to set the current time)", "time" },
3493     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3494         "add metadata", "string=string" },
3495     { "program",        HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3496         "add program with specified streams", "title=string:st=number..." },
3497     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3498                         OPT_OUTPUT,                                  { .func_arg = opt_data_frames },
3499         "set the number of data frames to output", "number" },
3500     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
3501         "add timings for benchmarking" },
3502     { "benchmark_all",  OPT_BOOL | OPT_EXPERT,                       { &do_benchmark_all },
3503       "add timings for each task" },
3504     { "progress",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_progress },
3505       "write program-readable progress information", "url" },
3506     { "stdin",          OPT_BOOL | OPT_EXPERT,                       { &stdin_interaction },
3507       "enable or disable interaction on standard input" },
3508     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
3509         "set max runtime in seconds in CPU user time", "limit" },
3510     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
3511         "dump each input packet" },
3512     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
3513         "when dumping packets, also dump the payload" },
3514     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3515                         OPT_INPUT,                                   { .off = OFFSET(rate_emu) },
3516         "read input at native frame rate", "" },
3517     { "target",         HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_target },
3518         "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3519         "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3520     { "vsync",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_vsync },
3521         "video sync method", "" },
3522     { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,      { &frame_drop_threshold },
3523         "frame drop threshold", "" },
3524     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
3525         "audio sync method", "" },
3526     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
3527         "audio drift threshold", "threshold" },
3528     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
3529         "copy timestamps" },
3530     { "start_at_zero",  OPT_BOOL | OPT_EXPERT,                       { &start_at_zero },
3531         "shift input timestamps to start at 0 when using copyts" },
3532     { "copytb",         HAS_ARG | OPT_INT | OPT_EXPERT,              { &copy_tb },
3533         "copy input stream time base when stream copying", "mode" },
3534     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3535                         OPT_OUTPUT,                                  { .off = OFFSET(shortest) },
3536         "finish encoding within shortest input" },
3537     { "bitexact",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3538                         OPT_OUTPUT | OPT_INPUT,                      { .off = OFFSET(bitexact) },
3539         "bitexact mode" },
3540     { "apad",           OPT_STRING | HAS_ARG | OPT_SPEC |
3541                         OPT_OUTPUT,                                  { .off = OFFSET(apad) },
3542         "audio pad", "" },
3543     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
3544         "timestamp discontinuity delta threshold", "threshold" },
3545     { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_error_threshold },
3546         "timestamp error delta threshold", "threshold" },
3547     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
3548         "exit on error", "error" },
3549     { "abort_on",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_abort_on },
3550         "abort on the specified condition flags", "flags" },
3551     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3552                         OPT_OUTPUT,                                  { .off = OFFSET(copy_initial_nonkeyframes) },
3553         "copy initial non-keyframes" },
3554     { "copypriorss",    OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,   { .off = OFFSET(copy_prior_start) },
3555         "copy or discard frames before start time" },
3556     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3557         "set the number of frames to output", "number" },
3558     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC |
3559                         OPT_EXPERT | OPT_OUTPUT | OPT_INPUT,         { .off = OFFSET(codec_tags) },
3560         "force codec tag/fourcc", "fourcc/tag" },
3561     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3562                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
3563         "use fixed quality scale (VBR)", "q" },
3564     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3565                         OPT_OUTPUT,                                  { .func_arg = opt_qscale },
3566         "use fixed quality scale (VBR)", "q" },
3567     { "profile",        HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3568         "set profile", "profile" },
3569     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3570         "set stream filtergraph", "filter_graph" },
3571     { "filter_threads",  HAS_ARG | OPT_INT,                          { &filter_nbthreads },
3572         "number of non-complex filter threads" },
3573     { "filter_script",  HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3574         "read stream filtergraph description from a file", "filename" },
3575     { "reinit_filter",  HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT,    { .off = OFFSET(reinit_filters) },
3576         "reinit filtergraph on input parameter changes", "" },
3577     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
3578         "create a complex filtergraph", "graph_description" },
3579     { "filter_complex_threads", HAS_ARG | OPT_INT,                   { &filter_complex_nbthreads },
3580         "number of threads for -filter_complex" },
3581     { "lavfi",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
3582         "create a complex filtergraph", "graph_description" },
3583     { "filter_complex_script", HAS_ARG | OPT_EXPERT,                 { .func_arg = opt_filter_complex_script },
3584         "read complex filtergraph description from a file", "filename" },
3585     { "auto_conversion_filters", OPT_BOOL | OPT_EXPERT,              { &auto_conversion_filters },
3586         "enable automatic conversion filters globally" },
3587     { "stats",          OPT_BOOL,                                    { &print_stats },
3588         "print progress report during encoding", },
3589     { "stats_period",    HAS_ARG | OPT_EXPERT,                       { .func_arg = opt_stats_period },
3590         "set the period at which ffmpeg updates stats and -progress output", "time" },
3591     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3592                         OPT_OUTPUT,                                  { .func_arg = opt_attach },
3593         "add an attachment to the output file", "filename" },
3594     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3595                          OPT_EXPERT | OPT_INPUT,                     { .off = OFFSET(dump_attachment) },
3596         "extract an attachment into a file", "filename" },
3597     { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3598                         OPT_OFFSET,                                  { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3599     { "debug_ts",       OPT_BOOL | OPT_EXPERT,                       { &debug_ts },
3600         "print timestamp debugging info" },
3601     { "max_error_rate",  HAS_ARG | OPT_FLOAT,                        { &max_error_rate },
3602         "ratio of decoding errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success.", "maximum error rate" },
3603     { "discard",        OPT_STRING | HAS_ARG | OPT_SPEC |
3604                         OPT_INPUT,                                   { .off = OFFSET(discard) },
3605         "discard", "" },
3606     { "disposition",    OPT_STRING | HAS_ARG | OPT_SPEC |
3607                         OPT_OUTPUT,                                  { .off = OFFSET(disposition) },
3608         "disposition", "" },
3609     { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3610                                                                      { .off = OFFSET(thread_queue_size) },
3611         "set the maximum number of queued packets from the demuxer" },
3612     { "find_stream_info", OPT_BOOL | OPT_PERFILE | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3613         "read and decode the streams to fill missing information with heuristics" },
3614
3615     /* video options */
3616     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_frames },
3617         "set the number of video frames to output", "number" },
3618     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
3619                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_rates) },
3620         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3621     { "fpsmax",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
3622                       OPT_OUTPUT,                                                { .off = OFFSET(max_frame_rates) },
3623         "set max frame rate (Hz value, fraction or abbreviation)", "rate" },
3624     { "s",            OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3625                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_sizes) },
3626         "set frame size (WxH or abbreviation)", "size" },
3627     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
3628                       OPT_OUTPUT,                                                { .off = OFFSET(frame_aspect_ratios) },
3629         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3630     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3631                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_pix_fmts) },
3632         "set pixel format", "format" },
3633     { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG,                      { &frame_bits_per_raw_sample },
3634         "set the number of bits per raw sample", "number" },
3635     { "intra",        OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &intra_only },
3636         "deprecated use -g 1" },
3637     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3638         "disable video" },
3639     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3640                       OPT_OUTPUT,                                                { .off = OFFSET(rc_overrides) },
3641         "rate control override for specific intervals", "override" },
3642     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_INPUT |
3643                       OPT_OUTPUT,                                                { .func_arg = opt_video_codec },
3644         "force video codec ('copy' to copy stream)", "codec" },
3645     { "sameq",        OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
3646         "Removed" },
3647     { "same_quant",   OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
3648         "Removed" },
3649     { "timecode",     OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_timecode },
3650         "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3651     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT,     { .off = OFFSET(pass) },
3652         "select the pass number (1 to 3)", "n" },
3653     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3654                       OPT_OUTPUT,                                                { .off = OFFSET(passlogfiles) },
3655         "select two pass log file name prefix", "prefix" },
3656     { "deinterlace",  OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_deinterlace },
3657         "this option is deprecated, use the yadif filter instead" },
3658     { "psnr",         OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_psnr },
3659         "calculate PSNR of compressed frames" },
3660     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_vstats },
3661         "dump video coding statistics to file" },
3662     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { .func_arg = opt_vstats_file },
3663         "dump video coding statistics to file", "file" },
3664     { "vstats_version",  OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,            { &vstats_version },
3665         "Version of the vstats format to use."},
3666     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_filters },
3667         "set video filters", "filter_graph" },
3668     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3669                       OPT_OUTPUT,                                                { .off = OFFSET(intra_matrices) },
3670         "specify intra matrix coeffs", "matrix" },
3671     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3672                       OPT_OUTPUT,                                                { .off = OFFSET(inter_matrices) },
3673         "specify inter matrix coeffs", "matrix" },
3674     { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3675                       OPT_OUTPUT,                                                { .off = OFFSET(chroma_intra_matrices) },
3676         "specify intra matrix coeffs", "matrix" },
3677     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC |
3678                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(top_field_first) },
3679         "top=1/bottom=0/auto=-1 field first", "" },
3680     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE |
3681                       OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_old2new },
3682         "force video tag/fourcc", "fourcc/tag" },
3683     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
3684         "show QP histogram" },
3685     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC |
3686                       OPT_OUTPUT,                                                { .off = OFFSET(force_fps) },
3687         "force the selected framerate, disable the best supported framerate selection" },
3688     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3689                       OPT_OUTPUT,                                                { .func_arg = opt_streamid },
3690         "set the value of an outfile streamid", "streamIndex:value" },
3691     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3692                           OPT_SPEC | OPT_OUTPUT,                                 { .off = OFFSET(forced_key_frames) },
3693         "force key frames at specified timestamps", "timestamps" },
3694     { "ab",           OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
3695         "audio bitrate (please use -b:a)", "bitrate" },
3696     { "b",            OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
3697         "video bitrate (please use -b:v)", "bitrate" },
3698     { "hwaccel",          OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3699                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccels) },
3700         "use HW accelerated decoding", "hwaccel name" },
3701     { "hwaccel_device",   OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3702                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_devices) },
3703         "select a device for HW acceleration", "devicename" },
3704     { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3705                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_output_formats) },
3706         "select output format used with HW accelerated decoding", "format" },
3707 #if CONFIG_VIDEOTOOLBOX
3708     { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3709 #endif
3710     { "hwaccels",         OPT_EXIT,                                              { .func_arg = show_hwaccels },
3711         "show available HW acceleration methods" },
3712     { "autorotate",       HAS_ARG | OPT_BOOL | OPT_SPEC |
3713                           OPT_EXPERT | OPT_INPUT,                                { .off = OFFSET(autorotate) },
3714         "automatically insert correct rotate filters" },
3715     { "autoscale",        HAS_ARG | OPT_BOOL | OPT_SPEC |
3716                           OPT_EXPERT | OPT_OUTPUT,                               { .off = OFFSET(autoscale) },
3717         "automatically insert a scale filter at the end of the filter graph" },
3718
3719     /* audio options */
3720     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_frames },
3721         "set the number of audio frames to output", "number" },
3722     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_qscale },
3723         "set audio quality (codec-specific)", "quality", },
3724     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
3725                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_sample_rate) },
3726         "set audio sampling rate (in Hz)", "rate" },
3727     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
3728                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_channels) },
3729         "set number of audio channels", "channels" },
3730     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3731         "disable audio" },
3732     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE |
3733                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_audio_codec },
3734         "force audio codec ('copy' to copy stream)", "codec" },
3735     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
3736                         OPT_OUTPUT,                                                { .func_arg = opt_old2new },
3737         "force audio tag/fourcc", "fourcc/tag" },
3738     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
3739         "change audio volume (256=normal)" , "volume" },
3740     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC |
3741                         OPT_STRING | OPT_INPUT | OPT_OUTPUT,                       { .off = OFFSET(sample_fmts) },
3742         "set sample format", "format" },
3743     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
3744                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_channel_layout },
3745         "set channel layout", "layout" },
3746     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_filters },
3747         "set audio filters", "filter_graph" },
3748     { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3749       "set the maximum number of channels to try to guess the channel layout" },
3750
3751     /* subtitle options */
3752     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3753         "disable subtitle" },
3754     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3755         "force subtitle codec ('copy' to copy stream)", "codec" },
3756     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3757         , "force subtitle tag/fourcc", "fourcc/tag" },
3758     { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3759         "fix subtitles duration" },
3760     { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3761         "set canvas size (WxH or abbreviation)", "size" },
3762
3763     /* grab options */
3764     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3765         "deprecated, use -channel", "channel" },
3766     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3767         "deprecated, use -standard", "standard" },
3768     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3769
3770     /* muxer options */
3771     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3772         "set the maximum demux-decode delay", "seconds" },
3773     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3774         "set the initial demux-decode delay", "seconds" },
3775     { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3776         "specify a file in which to print sdp information", "file" },
3777
3778     { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3779         "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3780     { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) },
3781         "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
3782         "two special values are defined - "
3783         "0 = use frame rate (video) or sample rate (audio),"
3784         "-1 = match source time base", "ratio" },
3785
3786     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3787         "A comma-separated list of bitstream filters", "bitstream_filters" },
3788     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3789         "deprecated", "audio bitstream_filters" },
3790     { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3791         "deprecated", "video bitstream_filters" },
3792
3793     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
3794         "set the audio options to the indicated preset", "preset" },
3795     { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
3796         "set the video options to the indicated preset", "preset" },
3797     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3798         "set the subtitle options to the indicated preset", "preset" },
3799     { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,                { .func_arg = opt_preset },
3800         "set options from indicated preset file", "filename" },
3801
3802     { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3803         "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3804     { "muxing_queue_data_threshold", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(muxing_queue_data_threshold) },
3805         "set the threshold after which max_muxing_queue_size is taken into account", "bytes" },
3806
3807     /* data codec support */
3808     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3809         "force data codec ('copy' to copy stream)", "codec" },
3810     { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3811         "disable data" },
3812
3813 #if CONFIG_VAAPI
3814     { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3815         "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3816 #endif
3817
3818 #if CONFIG_QSV
3819     { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3820         "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
3821 #endif
3822
3823     { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
3824         "initialise hardware device", "args" },
3825     { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
3826         "set hardware device used when filtering", "device" },
3827
3828     { NULL, },
3829 };