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