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

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