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

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