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

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