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