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