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