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

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