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

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