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