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