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

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