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

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