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

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