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                 if (ist->user_set_discard == AVDISCARD_ALL)
2203                     continue;
2204                 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2205                     new_area = 1;
2206                 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2207                     new_area > area) {
2208                     if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2209                         continue;
2210                     area = new_area;
2211                     idx = i;
2212                 }
2213             }
2214             if (idx >= 0)
2215                 new_video_stream(o, oc, idx);
2216         }
2217
2218         /* audio: most channels */
2219         if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2220             int best_score = 0, idx = -1;
2221             for (i = 0; i < nb_input_streams; i++) {
2222                 int score;
2223                 ist = input_streams[i];
2224                 score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames;
2225                 if (ist->user_set_discard == AVDISCARD_ALL)
2226                     continue;
2227                 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2228                     score > best_score) {
2229                     best_score = score;
2230                     idx = i;
2231                 }
2232             }
2233             if (idx >= 0)
2234                 new_audio_stream(o, oc, idx);
2235         }
2236
2237         /* subtitles: pick first */
2238         MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2239         if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2240             for (i = 0; i < nb_input_streams; i++)
2241                 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2242                     AVCodecDescriptor const *input_descriptor =
2243                         avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2244                     AVCodecDescriptor const *output_descriptor = NULL;
2245                     AVCodec const *output_codec =
2246                         avcodec_find_encoder(oc->oformat->subtitle_codec);
2247                     int input_props = 0, output_props = 0;
2248                     if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2249                         continue;
2250                     if (output_codec)
2251                         output_descriptor = avcodec_descriptor_get(output_codec->id);
2252                     if (input_descriptor)
2253                         input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2254                     if (output_descriptor)
2255                         output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2256                     if (subtitle_codec_name ||
2257                         input_props & output_props ||
2258                         // Map dvb teletext which has neither property to any output subtitle encoder
2259                         input_descriptor && output_descriptor &&
2260                         (!input_descriptor->props ||
2261                          !output_descriptor->props)) {
2262                         new_subtitle_stream(o, oc, i);
2263                         break;
2264                     }
2265                 }
2266         }
2267         /* Data only if codec id match */
2268         if (!o->data_disable ) {
2269             enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2270             for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2271                 if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2272                     continue;
2273                 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2274                     && input_streams[i]->st->codecpar->codec_id == codec_id )
2275                     new_data_stream(o, oc, i);
2276             }
2277         }
2278     } else {
2279         for (i = 0; i < o->nb_stream_maps; i++) {
2280             StreamMap *map = &o->stream_maps[i];
2281
2282             if (map->disabled)
2283                 continue;
2284
2285             if (map->linklabel) {
2286                 FilterGraph *fg;
2287                 OutputFilter *ofilter = NULL;
2288                 int j, k;
2289
2290                 for (j = 0; j < nb_filtergraphs; j++) {
2291                     fg = filtergraphs[j];
2292                     for (k = 0; k < fg->nb_outputs; k++) {
2293                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
2294                         if (out && !strcmp(out->name, map->linklabel)) {
2295                             ofilter = fg->outputs[k];
2296                             goto loop_end;
2297                         }
2298                     }
2299                 }
2300 loop_end:
2301                 if (!ofilter) {
2302                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2303                            "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2304                     exit_program(1);
2305                 }
2306                 init_output_filter(ofilter, o, oc);
2307             } else {
2308                 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2309
2310                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2311                 if (ist->user_set_discard == AVDISCARD_ALL) {
2312                     av_log(NULL, AV_LOG_FATAL, "Stream #%d:%d is disabled and cannot be mapped.\n",
2313                            map->file_index, map->stream_index);
2314                     exit_program(1);
2315                 }
2316                 if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2317                     continue;
2318                 if(o->   audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2319                     continue;
2320                 if(o->   video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2321                     continue;
2322                 if(o->    data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2323                     continue;
2324
2325                 ost = NULL;
2326                 switch (ist->st->codecpar->codec_type) {
2327                 case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
2328                 case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
2329                 case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
2330                 case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
2331                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2332                 case AVMEDIA_TYPE_UNKNOWN:
2333                     if (copy_unknown_streams) {
2334                         ost = new_unknown_stream   (o, oc, src_idx);
2335                         break;
2336                     }
2337                 default:
2338                     av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2339                            "Cannot map stream #%d:%d - unsupported type.\n",
2340                            map->file_index, map->stream_index);
2341                     if (!ignore_unknown_streams) {
2342                         av_log(NULL, AV_LOG_FATAL,
2343                                "If you want unsupported types ignored instead "
2344                                "of failing, please use the -ignore_unknown option\n"
2345                                "If you want them copied, please use -copy_unknown\n");
2346                         exit_program(1);
2347                     }
2348                 }
2349                 if (ost)
2350                     ost->sync_ist = input_streams[  input_files[map->sync_file_index]->ist_index
2351                                                   + map->sync_stream_index];
2352             }
2353         }
2354     }
2355
2356     /* handle attached files */
2357     for (i = 0; i < o->nb_attachments; i++) {
2358         AVIOContext *pb;
2359         uint8_t *attachment;
2360         const char *p;
2361         int64_t len;
2362
2363         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2364             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2365                    o->attachments[i]);
2366             exit_program(1);
2367         }
2368         if ((len = avio_size(pb)) <= 0) {
2369             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2370                    o->attachments[i]);
2371             exit_program(1);
2372         }
2373         if (!(attachment = av_malloc(len))) {
2374             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2375                    o->attachments[i]);
2376             exit_program(1);
2377         }
2378         avio_read(pb, attachment, len);
2379
2380         ost = new_attachment_stream(o, oc, -1);
2381         ost->stream_copy               = 0;
2382         ost->attachment_filename       = o->attachments[i];
2383         ost->st->codecpar->extradata      = attachment;
2384         ost->st->codecpar->extradata_size = len;
2385
2386         p = strrchr(o->attachments[i], '/');
2387         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2388         avio_closep(&pb);
2389     }
2390
2391 #if FF_API_LAVF_AVCTX
2392     for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2393         AVDictionaryEntry *e;
2394         ost = output_streams[i];
2395
2396         if ((ost->stream_copy || ost->attachment_filename)
2397             && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2398             && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2399             if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2400                 exit_program(1);
2401     }
2402 #endif
2403
2404     if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2405         av_dump_format(oc, nb_output_files - 1, oc->url, 1);
2406         av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2407         exit_program(1);
2408     }
2409
2410     /* check if all codec options have been used */
2411     unused_opts = strip_specifiers(o->g->codec_opts);
2412     for (i = of->ost_index; i < nb_output_streams; i++) {
2413         e = NULL;
2414         while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2415                                 AV_DICT_IGNORE_SUFFIX)))
2416             av_dict_set(&unused_opts, e->key, NULL, 0);
2417     }
2418
2419     e = NULL;
2420     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2421         const AVClass *class = avcodec_get_class();
2422         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2423                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2424         const AVClass *fclass = avformat_get_class();
2425         const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2426                                               AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2427         if (!option || foption)
2428             continue;
2429
2430
2431         if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2432             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2433                    "output file #%d (%s) is not an encoding option.\n", e->key,
2434                    option->help ? option->help : "", nb_output_files - 1,
2435                    filename);
2436             exit_program(1);
2437         }
2438
2439         // gop_timecode is injected by generic code but not always used
2440         if (!strcmp(e->key, "gop_timecode"))
2441             continue;
2442
2443         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2444                "output file #%d (%s) has not been used for any stream. The most "
2445                "likely reason is either wrong type (e.g. a video option with "
2446                "no video streams) or that it is a private option of some encoder "
2447                "which was not actually used for any stream.\n", e->key,
2448                option->help ? option->help : "", nb_output_files - 1, filename);
2449     }
2450     av_dict_free(&unused_opts);
2451
2452     /* set the decoding_needed flags and create simple filtergraphs */
2453     for (i = of->ost_index; i < nb_output_streams; i++) {
2454         OutputStream *ost = output_streams[i];
2455
2456         if (ost->encoding_needed && ost->source_index >= 0) {
2457             InputStream *ist = input_streams[ost->source_index];
2458             ist->decoding_needed |= DECODING_FOR_OST;
2459
2460             if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2461                 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2462                 err = init_simple_filtergraph(ist, ost);
2463                 if (err < 0) {
2464                     av_log(NULL, AV_LOG_ERROR,
2465                            "Error initializing a simple filtergraph between streams "
2466                            "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2467                            nb_output_files - 1, ost->st->index);
2468                     exit_program(1);
2469                 }
2470             }
2471         }
2472
2473         /* set the filter output constraints */
2474         if (ost->filter) {
2475             OutputFilter *f = ost->filter;
2476             int count;
2477             switch (ost->enc_ctx->codec_type) {
2478             case AVMEDIA_TYPE_VIDEO:
2479                 f->frame_rate = ost->frame_rate;
2480                 f->width      = ost->enc_ctx->width;
2481                 f->height     = ost->enc_ctx->height;
2482                 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2483                     f->format = ost->enc_ctx->pix_fmt;
2484                 } else if (ost->enc->pix_fmts) {
2485                     count = 0;
2486                     while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2487                         count++;
2488                     f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2489                     if (!f->formats)
2490                         exit_program(1);
2491                     memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2492                 }
2493                 break;
2494             case AVMEDIA_TYPE_AUDIO:
2495                 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2496                     f->format = ost->enc_ctx->sample_fmt;
2497                 } else if (ost->enc->sample_fmts) {
2498                     count = 0;
2499                     while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2500                         count++;
2501                     f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2502                     if (!f->formats)
2503                         exit_program(1);
2504                     memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2505                 }
2506                 if (ost->enc_ctx->sample_rate) {
2507                     f->sample_rate = ost->enc_ctx->sample_rate;
2508                 } else if (ost->enc->supported_samplerates) {
2509                     count = 0;
2510                     while (ost->enc->supported_samplerates[count])
2511                         count++;
2512                     f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2513                     if (!f->sample_rates)
2514                         exit_program(1);
2515                     memcpy(f->sample_rates, ost->enc->supported_samplerates,
2516                            (count + 1) * sizeof(*f->sample_rates));
2517                 }
2518                 if (ost->enc_ctx->channels) {
2519                     f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2520                 } else if (ost->enc->channel_layouts) {
2521                     count = 0;
2522                     while (ost->enc->channel_layouts[count])
2523                         count++;
2524                     f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2525                     if (!f->channel_layouts)
2526                         exit_program(1);
2527                     memcpy(f->channel_layouts, ost->enc->channel_layouts,
2528                            (count + 1) * sizeof(*f->channel_layouts));
2529                 }
2530                 break;
2531             }
2532         }
2533     }
2534
2535     /* check filename in case of an image number is expected */
2536     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2537         if (!av_filename_number_test(oc->url)) {
2538             print_error(oc->url, AVERROR(EINVAL));
2539             exit_program(1);
2540         }
2541     }
2542
2543     if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2544         av_log(NULL, AV_LOG_ERROR,
2545                "No input streams but output needs an input stream\n");
2546         exit_program(1);
2547     }
2548
2549     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2550         /* test if it already exists to avoid losing precious files */
2551         assert_file_overwrite(filename);
2552
2553         /* open the file */
2554         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2555                               &oc->interrupt_callback,
2556                               &of->opts)) < 0) {
2557             print_error(filename, err);
2558             exit_program(1);
2559         }
2560     } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2561         assert_file_overwrite(filename);
2562
2563     if (o->mux_preload) {
2564         av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2565     }
2566     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2567
2568     /* copy metadata */
2569     for (i = 0; i < o->nb_metadata_map; i++) {
2570         char *p;
2571         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2572
2573         if (in_file_index >= nb_input_files) {
2574             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2575             exit_program(1);
2576         }
2577         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2578                       in_file_index >= 0 ?
2579                       input_files[in_file_index]->ctx : NULL, o);
2580     }
2581
2582     /* copy chapters */
2583     if (o->chapters_input_file >= nb_input_files) {
2584         if (o->chapters_input_file == INT_MAX) {
2585             /* copy chapters from the first input file that has them*/
2586             o->chapters_input_file = -1;
2587             for (i = 0; i < nb_input_files; i++)
2588                 if (input_files[i]->ctx->nb_chapters) {
2589                     o->chapters_input_file = i;
2590                     break;
2591                 }
2592         } else {
2593             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2594                    o->chapters_input_file);
2595             exit_program(1);
2596         }
2597     }
2598     if (o->chapters_input_file >= 0)
2599         copy_chapters(input_files[o->chapters_input_file], of,
2600                       !o->metadata_chapters_manual);
2601
2602     /* copy global metadata by default */
2603     if (!o->metadata_global_manual && nb_input_files){
2604         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2605                      AV_DICT_DONT_OVERWRITE);
2606         if(o->recording_time != INT64_MAX)
2607             av_dict_set(&oc->metadata, "duration", NULL, 0);
2608         av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2609     }
2610     if (!o->metadata_streams_manual)
2611         for (i = of->ost_index; i < nb_output_streams; i++) {
2612             InputStream *ist;
2613             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
2614                 continue;
2615             ist = input_streams[output_streams[i]->source_index];
2616             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2617             if (!output_streams[i]->stream_copy) {
2618                 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2619             }
2620         }
2621
2622     /* process manually set programs */
2623     for (i = 0; i < o->nb_program; i++) {
2624         const char *p = o->program[i].u.str;
2625         int progid = i+1;
2626         AVProgram *program;
2627
2628         while(*p) {
2629             const char *p2 = av_get_token(&p, ":");
2630             const char *to_dealloc = p2;
2631             char *key;
2632             if (!p2)
2633                 break;
2634
2635             if(*p) p++;
2636
2637             key = av_get_token(&p2, "=");
2638             if (!key || !*p2) {
2639                 av_freep(&to_dealloc);
2640                 av_freep(&key);
2641                 break;
2642             }
2643             p2++;
2644
2645             if (!strcmp(key, "program_num"))
2646                 progid = strtol(p2, NULL, 0);
2647             av_freep(&to_dealloc);
2648             av_freep(&key);
2649         }
2650
2651         program = av_new_program(oc, progid);
2652
2653         p = o->program[i].u.str;
2654         while(*p) {
2655             const char *p2 = av_get_token(&p, ":");
2656             const char *to_dealloc = p2;
2657             char *key;
2658             if (!p2)
2659                 break;
2660             if(*p) p++;
2661
2662             key = av_get_token(&p2, "=");
2663             if (!key) {
2664                 av_log(NULL, AV_LOG_FATAL,
2665                        "No '=' character in program string %s.\n",
2666                        p2);
2667                 exit_program(1);
2668             }
2669             if (!*p2)
2670                 exit_program(1);
2671             p2++;
2672
2673             if (!strcmp(key, "title")) {
2674                 av_dict_set(&program->metadata, "title", p2, 0);
2675             } else if (!strcmp(key, "program_num")) {
2676             } else if (!strcmp(key, "st")) {
2677                 int st_num = strtol(p2, NULL, 0);
2678                 av_program_add_stream_index(oc, progid, st_num);
2679             } else {
2680                 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2681                 exit_program(1);
2682             }
2683             av_freep(&to_dealloc);
2684             av_freep(&key);
2685         }
2686     }
2687
2688     /* process manually set metadata */
2689     for (i = 0; i < o->nb_metadata; i++) {
2690         AVDictionary **m;
2691         char type, *val;
2692         const char *stream_spec;
2693         int index = 0, j, ret = 0;
2694
2695         val = strchr(o->metadata[i].u.str, '=');
2696         if (!val) {
2697             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2698                    o->metadata[i].u.str);
2699             exit_program(1);
2700         }
2701         *val++ = 0;
2702
2703         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2704         if (type == 's') {
2705             for (j = 0; j < oc->nb_streams; j++) {
2706                 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2707                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2708                     if (!strcmp(o->metadata[i].u.str, "rotate")) {
2709                         char *tail;
2710                         double theta = av_strtod(val, &tail);
2711                         if (!*tail) {
2712                             ost->rotate_overridden = 1;
2713                             ost->rotate_override_value = theta;
2714                         }
2715                     } else {
2716                         av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2717                     }
2718                 } else if (ret < 0)
2719                     exit_program(1);
2720             }
2721         }
2722         else {
2723             switch (type) {
2724             case 'g':
2725                 m = &oc->metadata;
2726                 break;
2727             case 'c':
2728                 if (index < 0 || index >= oc->nb_chapters) {
2729                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2730                     exit_program(1);
2731                 }
2732                 m = &oc->chapters[index]->metadata;
2733                 break;
2734             case 'p':
2735                 if (index < 0 || index >= oc->nb_programs) {
2736                     av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2737                     exit_program(1);
2738                 }
2739                 m = &oc->programs[index]->metadata;
2740                 break;
2741             default:
2742                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2743                 exit_program(1);
2744             }
2745             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2746         }
2747     }
2748
2749     return 0;
2750 }
2751
2752 static int opt_target(void *optctx, const char *opt, const char *arg)
2753 {
2754     OptionsContext *o = optctx;
2755     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2756     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2757
2758     if (!strncmp(arg, "pal-", 4)) {
2759         norm = PAL;
2760         arg += 4;
2761     } else if (!strncmp(arg, "ntsc-", 5)) {
2762         norm = NTSC;
2763         arg += 5;
2764     } else if (!strncmp(arg, "film-", 5)) {
2765         norm = FILM;
2766         arg += 5;
2767     } else {
2768         /* Try to determine PAL/NTSC by peeking in the input files */
2769         if (nb_input_files) {
2770             int i, j, fr;
2771             for (j = 0; j < nb_input_files; j++) {
2772                 for (i = 0; i < input_files[j]->nb_streams; i++) {
2773                     AVStream *st = input_files[j]->ctx->streams[i];
2774                     if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2775                         continue;
2776                     fr = st->time_base.den * 1000 / st->time_base.num;
2777                     if (fr == 25000) {
2778                         norm = PAL;
2779                         break;
2780                     } else if ((fr == 29970) || (fr == 23976)) {
2781                         norm = NTSC;
2782                         break;
2783                     }
2784                 }
2785                 if (norm != UNKNOWN)
2786                     break;
2787             }
2788         }
2789         if (norm != UNKNOWN)
2790             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2791     }
2792
2793     if (norm == UNKNOWN) {
2794         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2795         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2796         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2797         exit_program(1);
2798     }
2799
2800     if (!strcmp(arg, "vcd")) {
2801         opt_video_codec(o, "c:v", "mpeg1video");
2802         opt_audio_codec(o, "c:a", "mp2");
2803         parse_option(o, "f", "vcd", options);
2804
2805         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2806         parse_option(o, "r", frame_rates[norm], options);
2807         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2808
2809         opt_default(NULL, "b:v", "1150000");
2810         opt_default(NULL, "maxrate:v", "1150000");
2811         opt_default(NULL, "minrate:v", "1150000");
2812         opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2813
2814         opt_default(NULL, "b:a", "224000");
2815         parse_option(o, "ar", "44100", options);
2816         parse_option(o, "ac", "2", options);
2817
2818         opt_default(NULL, "packetsize", "2324");
2819         opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2820
2821         /* We have to offset the PTS, so that it is consistent with the SCR.
2822            SCR starts at 36000, but the first two packs contain only padding
2823            and the first pack from the other stream, respectively, may also have
2824            been written before.
2825            So the real data starts at SCR 36000+3*1200. */
2826         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2827     } else if (!strcmp(arg, "svcd")) {
2828
2829         opt_video_codec(o, "c:v", "mpeg2video");
2830         opt_audio_codec(o, "c:a", "mp2");
2831         parse_option(o, "f", "svcd", options);
2832
2833         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2834         parse_option(o, "r", frame_rates[norm], options);
2835         parse_option(o, "pix_fmt", "yuv420p", options);
2836         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2837
2838         opt_default(NULL, "b:v", "2040000");
2839         opt_default(NULL, "maxrate:v", "2516000");
2840         opt_default(NULL, "minrate:v", "0"); // 1145000;
2841         opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2842         opt_default(NULL, "scan_offset", "1");
2843
2844         opt_default(NULL, "b:a", "224000");
2845         parse_option(o, "ar", "44100", options);
2846
2847         opt_default(NULL, "packetsize", "2324");
2848
2849     } else if (!strcmp(arg, "dvd")) {
2850
2851         opt_video_codec(o, "c:v", "mpeg2video");
2852         opt_audio_codec(o, "c:a", "ac3");
2853         parse_option(o, "f", "dvd", options);
2854
2855         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2856         parse_option(o, "r", frame_rates[norm], options);
2857         parse_option(o, "pix_fmt", "yuv420p", options);
2858         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2859
2860         opt_default(NULL, "b:v", "6000000");
2861         opt_default(NULL, "maxrate:v", "9000000");
2862         opt_default(NULL, "minrate:v", "0"); // 1500000;
2863         opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2864
2865         opt_default(NULL, "packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2866         opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2867
2868         opt_default(NULL, "b:a", "448000");
2869         parse_option(o, "ar", "48000", options);
2870
2871     } else if (!strncmp(arg, "dv", 2)) {
2872
2873         parse_option(o, "f", "dv", options);
2874
2875         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2876         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2877                           norm == PAL ? "yuv420p" : "yuv411p", options);
2878         parse_option(o, "r", frame_rates[norm], options);
2879
2880         parse_option(o, "ar", "48000", options);
2881         parse_option(o, "ac", "2", options);
2882
2883     } else {
2884         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2885         return AVERROR(EINVAL);
2886     }
2887
2888     av_dict_copy(&o->g->codec_opts,  codec_opts, AV_DICT_DONT_OVERWRITE);
2889     av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2890
2891     return 0;
2892 }
2893
2894 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2895 {
2896     av_free (vstats_filename);
2897     vstats_filename = av_strdup (arg);
2898     return 0;
2899 }
2900
2901 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2902 {
2903     char filename[40];
2904     time_t today2 = time(NULL);
2905     struct tm *today = localtime(&today2);
2906
2907     if (!today) { // maybe tomorrow
2908         av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2909         exit_program(1);
2910     }
2911
2912     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2913              today->tm_sec);
2914     return opt_vstats_file(NULL, opt, filename);
2915 }
2916
2917 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2918 {
2919     OptionsContext *o = optctx;
2920     return parse_option(o, "frames:v", arg, options);
2921 }
2922
2923 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2924 {
2925     OptionsContext *o = optctx;
2926     return parse_option(o, "frames:a", arg, options);
2927 }
2928
2929 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2930 {
2931     OptionsContext *o = optctx;
2932     return parse_option(o, "frames:d", arg, options);
2933 }
2934
2935 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2936 {
2937     int ret;
2938     AVDictionary *cbak = codec_opts;
2939     AVDictionary *fbak = format_opts;
2940     codec_opts = NULL;
2941     format_opts = NULL;
2942
2943     ret = opt_default(NULL, opt, arg);
2944
2945     av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2946     av_dict_copy(&o->g->format_opts, format_opts, 0);
2947     av_dict_free(&codec_opts);
2948     av_dict_free(&format_opts);
2949     codec_opts = cbak;
2950     format_opts = fbak;
2951
2952     return ret;
2953 }
2954
2955 static int opt_preset(void *optctx, const char *opt, const char *arg)
2956 {
2957     OptionsContext *o = optctx;
2958     FILE *f=NULL;
2959     char filename[1000], line[1000], tmp_line[1000];
2960     const char *codec_name = NULL;
2961
2962     tmp_line[0] = *opt;
2963     tmp_line[1] = 0;
2964     MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2965
2966     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2967         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2968             av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2969         }else
2970             av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2971         exit_program(1);
2972     }
2973
2974     while (fgets(line, sizeof(line), f)) {
2975         char *key = tmp_line, *value, *endptr;
2976
2977         if (strcspn(line, "#\n\r") == 0)
2978             continue;
2979         av_strlcpy(tmp_line, line, sizeof(tmp_line));
2980         if (!av_strtok(key,   "=",    &value) ||
2981             !av_strtok(value, "\r\n", &endptr)) {
2982             av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2983             exit_program(1);
2984         }
2985         av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2986
2987         if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
2988         else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
2989         else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2990         else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
2991         else if (opt_default_new(o, key, value) < 0) {
2992             av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2993                    filename, line, key, value);
2994             exit_program(1);
2995         }
2996     }
2997
2998     fclose(f);
2999
3000     return 0;
3001 }
3002
3003 static int opt_old2new(void *optctx, const char *opt, const char *arg)
3004 {
3005     OptionsContext *o = optctx;
3006     char *s = av_asprintf("%s:%c", opt + 1, *opt);
3007     int ret = parse_option(o, s, arg, options);
3008     av_free(s);
3009     return ret;
3010 }
3011
3012 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
3013 {
3014     OptionsContext *o = optctx;
3015
3016     if(!strcmp(opt, "ab")){
3017         av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
3018         return 0;
3019     } else if(!strcmp(opt, "b")){
3020         av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
3021         av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
3022         return 0;
3023     }
3024     av_dict_set(&o->g->codec_opts, opt, arg, 0);
3025     return 0;
3026 }
3027
3028 static int opt_qscale(void *optctx, const char *opt, const char *arg)
3029 {
3030     OptionsContext *o = optctx;
3031     char *s;
3032     int ret;
3033     if(!strcmp(opt, "qscale")){
3034         av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
3035         return parse_option(o, "q:v", arg, options);
3036     }
3037     s = av_asprintf("q%s", opt + 6);
3038     ret = parse_option(o, s, arg, options);
3039     av_free(s);
3040     return ret;
3041 }
3042
3043 static int opt_profile(void *optctx, const char *opt, const char *arg)
3044 {
3045     OptionsContext *o = optctx;
3046     if(!strcmp(opt, "profile")){
3047         av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
3048         av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
3049         return 0;
3050     }
3051     av_dict_set(&o->g->codec_opts, opt, arg, 0);
3052     return 0;
3053 }
3054
3055 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3056 {
3057     OptionsContext *o = optctx;
3058     return parse_option(o, "filter:v", arg, options);
3059 }
3060
3061 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3062 {
3063     OptionsContext *o = optctx;
3064     return parse_option(o, "filter:a", arg, options);
3065 }
3066
3067 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3068 {
3069     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
3070     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
3071     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3072     else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
3073
3074     if (video_sync_method == VSYNC_AUTO)
3075         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
3076     return 0;
3077 }
3078
3079 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3080 {
3081     OptionsContext *o = optctx;
3082     char *tcr = av_asprintf("timecode=%s", arg);
3083     int ret = parse_option(o, "metadata:g", tcr, options);
3084     if (ret >= 0)
3085         ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3086     av_free(tcr);
3087     return ret;
3088 }
3089
3090 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3091 {
3092     OptionsContext *o = optctx;
3093     char layout_str[32];
3094     char *stream_str;
3095     char *ac_str;
3096     int ret, channels, ac_str_size;
3097     uint64_t layout;
3098
3099     layout = av_get_channel_layout(arg);
3100     if (!layout) {
3101         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3102         return AVERROR(EINVAL);
3103     }
3104     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3105     ret = opt_default_new(o, opt, layout_str);
3106     if (ret < 0)
3107         return ret;
3108
3109     /* set 'ac' option based on channel layout */
3110     channels = av_get_channel_layout_nb_channels(layout);
3111     snprintf(layout_str, sizeof(layout_str), "%d", channels);
3112     stream_str = strchr(opt, ':');
3113     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3114     ac_str = av_mallocz(ac_str_size);
3115     if (!ac_str)
3116         return AVERROR(ENOMEM);
3117     av_strlcpy(ac_str, "ac", 3);
3118     if (stream_str)
3119         av_strlcat(ac_str, stream_str, ac_str_size);
3120     ret = parse_option(o, ac_str, layout_str, options);
3121     av_free(ac_str);
3122
3123     return ret;
3124 }
3125
3126 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3127 {
3128     OptionsContext *o = optctx;
3129     return parse_option(o, "q:a", arg, options);
3130 }
3131
3132 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3133 {
3134     GROW_ARRAY(filtergraphs, nb_filtergraphs);
3135     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3136         return AVERROR(ENOMEM);
3137     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
3138     filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
3139     if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3140         return AVERROR(ENOMEM);
3141
3142     input_stream_potentially_available = 1;
3143
3144     return 0;
3145 }
3146
3147 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3148 {
3149     uint8_t *graph_desc = read_file(arg);
3150     if (!graph_desc)
3151         return AVERROR(EINVAL);
3152
3153     GROW_ARRAY(filtergraphs, nb_filtergraphs);
3154     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3155         return AVERROR(ENOMEM);
3156     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
3157     filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3158
3159     input_stream_potentially_available = 1;
3160
3161     return 0;
3162 }
3163
3164 void show_help_default(const char *opt, const char *arg)
3165 {
3166     /* per-file options have at least one of those set */
3167     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3168     int show_advanced = 0, show_avoptions = 0;
3169
3170     if (opt && *opt) {
3171         if (!strcmp(opt, "long"))
3172             show_advanced = 1;
3173         else if (!strcmp(opt, "full"))
3174             show_advanced = show_avoptions = 1;
3175         else
3176             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3177     }
3178
3179     show_usage();
3180
3181     printf("Getting help:\n"
3182            "    -h      -- print basic options\n"
3183            "    -h long -- print more options\n"
3184            "    -h full -- print all options (including all format and codec specific options, very long)\n"
3185            "    -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter/bsf\n"
3186            "    See man %s for detailed description of the options.\n"
3187            "\n", program_name);
3188
3189     show_help_options(options, "Print help / information / capabilities:",
3190                       OPT_EXIT, 0, 0);
3191
3192     show_help_options(options, "Global options (affect whole program "
3193                       "instead of just one file:",
3194                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3195     if (show_advanced)
3196         show_help_options(options, "Advanced global options:", OPT_EXPERT,
3197                           per_file | OPT_EXIT, 0);
3198
3199     show_help_options(options, "Per-file main options:", 0,
3200                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3201                       OPT_EXIT, per_file);
3202     if (show_advanced)
3203         show_help_options(options, "Advanced per-file options:",
3204                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3205
3206     show_help_options(options, "Video options:",
3207                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3208     if (show_advanced)
3209         show_help_options(options, "Advanced Video options:",
3210                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3211
3212     show_help_options(options, "Audio options:",
3213                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3214     if (show_advanced)
3215         show_help_options(options, "Advanced Audio options:",
3216                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3217     show_help_options(options, "Subtitle options:",
3218                       OPT_SUBTITLE, 0, 0);
3219     printf("\n");
3220
3221     if (show_avoptions) {
3222         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3223         show_help_children(avcodec_get_class(), flags);
3224         show_help_children(avformat_get_class(), flags);
3225 #if CONFIG_SWSCALE
3226         show_help_children(sws_get_class(), flags);
3227 #endif
3228 #if CONFIG_SWRESAMPLE
3229         show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3230 #endif
3231         show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3232         show_help_children(av_bsf_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_BSF_PARAM);
3233     }
3234 }
3235
3236 void show_usage(void)
3237 {
3238     av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3239     av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3240     av_log(NULL, AV_LOG_INFO, "\n");
3241 }
3242
3243 enum OptGroup {
3244     GROUP_OUTFILE,
3245     GROUP_INFILE,
3246 };
3247
3248 static const OptionGroupDef groups[] = {
3249     [GROUP_OUTFILE] = { "output url",  NULL, OPT_OUTPUT },
3250     [GROUP_INFILE]  = { "input url",   "i",  OPT_INPUT },
3251 };
3252
3253 static int open_files(OptionGroupList *l, const char *inout,
3254                       int (*open_file)(OptionsContext*, const char*))
3255 {
3256     int i, ret;
3257
3258     for (i = 0; i < l->nb_groups; i++) {
3259         OptionGroup *g = &l->groups[i];
3260         OptionsContext o;
3261
3262         init_options(&o);
3263         o.g = g;
3264
3265         ret = parse_optgroup(&o, g);
3266         if (ret < 0) {
3267             av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3268                    "%s.\n", inout, g->arg);
3269             return ret;
3270         }
3271
3272         av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3273         ret = open_file(&o, g->arg);
3274         uninit_options(&o);
3275         if (ret < 0) {
3276             av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3277                    inout, g->arg);
3278             return ret;
3279         }
3280         av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3281     }
3282
3283     return 0;
3284 }
3285
3286 int ffmpeg_parse_options(int argc, char **argv)
3287 {
3288     OptionParseContext octx;
3289     uint8_t error[128];
3290     int ret;
3291
3292     memset(&octx, 0, sizeof(octx));
3293
3294     /* split the commandline into an internal representation */
3295     ret = split_commandline(&octx, argc, argv, options, groups,
3296                             FF_ARRAY_ELEMS(groups));
3297     if (ret < 0) {
3298         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3299         goto fail;
3300     }
3301
3302     /* apply global options */
3303     ret = parse_optgroup(NULL, &octx.global_opts);
3304     if (ret < 0) {
3305         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3306         goto fail;
3307     }
3308
3309     /* configure terminal and setup signal handlers */
3310     term_init();
3311
3312     /* open input files */
3313     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3314     if (ret < 0) {
3315         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3316         goto fail;
3317     }
3318
3319     /* create the complex filtergraphs */
3320     ret = init_complex_filters();
3321     if (ret < 0) {
3322         av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3323         goto fail;
3324     }
3325
3326     /* open output files */
3327     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3328     if (ret < 0) {
3329         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3330         goto fail;
3331     }
3332
3333     check_filter_outputs();
3334
3335 fail:
3336     uninit_parse_context(&octx);
3337     if (ret < 0) {
3338         av_strerror(ret, error, sizeof(error));
3339         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3340     }
3341     return ret;
3342 }
3343
3344 static int opt_progress(void *optctx, const char *opt, const char *arg)
3345 {
3346     AVIOContext *avio = NULL;
3347     int ret;
3348
3349     if (!strcmp(arg, "-"))
3350         arg = "pipe:";
3351     ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3352     if (ret < 0) {
3353         av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3354                arg, av_err2str(ret));
3355         return ret;
3356     }
3357     progress_avio = avio;
3358     return 0;
3359 }
3360
3361 #define OFFSET(x) offsetof(OptionsContext, x)
3362 const OptionDef options[] = {
3363     /* main options */
3364     CMDUTILS_COMMON_OPTIONS
3365     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET |
3366                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(format) },
3367         "force format", "fmt" },
3368     { "y",              OPT_BOOL,                                    {              &file_overwrite },
3369         "overwrite output files" },
3370     { "n",              OPT_BOOL,                                    {              &no_file_overwrite },
3371         "never overwrite output files" },
3372     { "ignore_unknown", OPT_BOOL,                                    {              &ignore_unknown_streams },
3373         "Ignore unknown stream types" },
3374     { "copy_unknown",   OPT_BOOL | OPT_EXPERT,                       {              &copy_unknown_streams },
3375         "Copy unknown stream types" },
3376     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC |
3377                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
3378         "codec name", "codec" },
3379     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC |
3380                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
3381         "codec name", "codec" },
3382     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC |
3383                         OPT_OUTPUT,                                  { .off       = OFFSET(presets) },
3384         "preset name", "preset" },
3385     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3386                         OPT_OUTPUT,                                  { .func_arg = opt_map },
3387         "set input stream mapping",
3388         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3389     { "map_channel",    HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3390         "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3391     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC |
3392                         OPT_OUTPUT,                                  { .off       = OFFSET(metadata_map) },
3393         "set metadata information of outfile from infile",
3394         "outfile[,metadata]:infile[,metadata]" },
3395     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3396                         OPT_OUTPUT,                                  { .off = OFFSET(chapters_input_file) },
3397         "set chapters mapping", "input_file_index" },
3398     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET |
3399                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(recording_time) },
3400         "record or transcode \"duration\" seconds of audio/video",
3401         "duration" },
3402     { "to",             HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,  { .off = OFFSET(stop_time) },
3403         "record or transcode stop time", "time_stop" },
3404     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3405         "set the limit file size in bytes", "limit_size" },
3406     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET |
3407                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time) },
3408         "set the start time offset", "time_off" },
3409     { "sseof",          HAS_ARG | OPT_TIME | OPT_OFFSET |
3410                         OPT_INPUT,                                   { .off = OFFSET(start_time_eof) },
3411         "set the start time offset relative to EOF", "time_off" },
3412     { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3413                         OPT_INPUT,                                   { .off = OFFSET(seek_timestamp) },
3414         "enable/disable seeking by timestamp with -ss" },
3415     { "accurate_seek",  OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3416                         OPT_INPUT,                                   { .off = OFFSET(accurate_seek) },
3417         "enable/disable accurate seeking with -ss" },
3418     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET |
3419                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(input_ts_offset) },
3420         "set the input ts offset", "time_off" },
3421     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3422                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(ts_scale) },
3423         "set the input ts scale", "scale" },
3424     { "timestamp",      HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_recording_timestamp },
3425         "set the recording timestamp ('now' to set the current time)", "time" },
3426     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3427         "add metadata", "string=string" },
3428     { "program",        HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3429         "add program with specified streams", "title=string:st=number..." },
3430     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3431                         OPT_OUTPUT,                                  { .func_arg = opt_data_frames },
3432         "set the number of data frames to output", "number" },
3433     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
3434         "add timings for benchmarking" },
3435     { "benchmark_all",  OPT_BOOL | OPT_EXPERT,                       { &do_benchmark_all },
3436       "add timings for each task" },
3437     { "progress",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_progress },
3438       "write program-readable progress information", "url" },
3439     { "stdin",          OPT_BOOL | OPT_EXPERT,                       { &stdin_interaction },
3440       "enable or disable interaction on standard input" },
3441     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
3442         "set max runtime in seconds", "limit" },
3443     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
3444         "dump each input packet" },
3445     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
3446         "when dumping packets, also dump the payload" },
3447     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3448                         OPT_INPUT,                                   { .off = OFFSET(rate_emu) },
3449         "read input at native frame rate", "" },
3450     { "target",         HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_target },
3451         "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3452         "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3453     { "vsync",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_vsync },
3454         "video sync method", "" },
3455     { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,      { &frame_drop_threshold },
3456         "frame drop threshold", "" },
3457     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
3458         "audio sync method", "" },
3459     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
3460         "audio drift threshold", "threshold" },
3461     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
3462         "copy timestamps" },
3463     { "start_at_zero",  OPT_BOOL | OPT_EXPERT,                       { &start_at_zero },
3464         "shift input timestamps to start at 0 when using copyts" },
3465     { "copytb",         HAS_ARG | OPT_INT | OPT_EXPERT,              { &copy_tb },
3466         "copy input stream time base when stream copying", "mode" },
3467     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3468                         OPT_OUTPUT,                                  { .off = OFFSET(shortest) },
3469         "finish encoding within shortest input" },
3470     { "bitexact",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3471                         OPT_OUTPUT | OPT_INPUT,                      { .off = OFFSET(bitexact) },
3472         "bitexact mode" },
3473     { "apad",           OPT_STRING | HAS_ARG | OPT_SPEC |
3474                         OPT_OUTPUT,                                  { .off = OFFSET(apad) },
3475         "audio pad", "" },
3476     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
3477         "timestamp discontinuity delta threshold", "threshold" },
3478     { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_error_threshold },
3479         "timestamp error delta threshold", "threshold" },
3480     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
3481         "exit on error", "error" },
3482     { "abort_on",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_abort_on },
3483         "abort on the specified condition flags", "flags" },
3484     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3485                         OPT_OUTPUT,                                  { .off = OFFSET(copy_initial_nonkeyframes) },
3486         "copy initial non-keyframes" },
3487     { "copypriorss",    OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,   { .off = OFFSET(copy_prior_start) },
3488         "copy or discard frames before start time" },
3489     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3490         "set the number of frames to output", "number" },
3491     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC |
3492                         OPT_EXPERT | OPT_OUTPUT | OPT_INPUT,         { .off = OFFSET(codec_tags) },
3493         "force codec tag/fourcc", "fourcc/tag" },
3494     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3495                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
3496         "use fixed quality scale (VBR)", "q" },
3497     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3498                         OPT_OUTPUT,                                  { .func_arg = opt_qscale },
3499         "use fixed quality scale (VBR)", "q" },
3500     { "profile",        HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3501         "set profile", "profile" },
3502     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3503         "set stream filtergraph", "filter_graph" },
3504     { "filter_threads",  HAS_ARG | OPT_INT,                          { &filter_nbthreads },
3505         "number of non-complex filter threads" },
3506     { "filter_script",  HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3507         "read stream filtergraph description from a file", "filename" },
3508     { "reinit_filter",  HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT,    { .off = OFFSET(reinit_filters) },
3509         "reinit filtergraph on input parameter changes", "" },
3510     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
3511         "create a complex filtergraph", "graph_description" },
3512     { "filter_complex_threads", HAS_ARG | OPT_INT,                   { &filter_complex_nbthreads },
3513         "number of threads for -filter_complex" },
3514     { "lavfi",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
3515         "create a complex filtergraph", "graph_description" },
3516     { "filter_complex_script", HAS_ARG | OPT_EXPERT,                 { .func_arg = opt_filter_complex_script },
3517         "read complex filtergraph description from a file", "filename" },
3518     { "stats",          OPT_BOOL,                                    { &print_stats },
3519         "print progress report during encoding", },
3520     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3521                         OPT_OUTPUT,                                  { .func_arg = opt_attach },
3522         "add an attachment to the output file", "filename" },
3523     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3524                          OPT_EXPERT | OPT_INPUT,                     { .off = OFFSET(dump_attachment) },
3525         "extract an attachment into a file", "filename" },
3526     { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3527                         OPT_OFFSET,                                  { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3528     { "debug_ts",       OPT_BOOL | OPT_EXPERT,                       { &debug_ts },
3529         "print timestamp debugging info" },
3530     { "max_error_rate",  HAS_ARG | OPT_FLOAT,                        { &max_error_rate },
3531         "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success.", "maximum error rate" },
3532     { "discard",        OPT_STRING | HAS_ARG | OPT_SPEC |
3533                         OPT_INPUT,                                   { .off = OFFSET(discard) },
3534         "discard", "" },
3535     { "disposition",    OPT_STRING | HAS_ARG | OPT_SPEC |
3536                         OPT_OUTPUT,                                  { .off = OFFSET(disposition) },
3537         "disposition", "" },
3538     { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3539                                                                      { .off = OFFSET(thread_queue_size) },
3540         "set the maximum number of queued packets from the demuxer" },
3541     { "find_stream_info", OPT_BOOL | OPT_PERFILE | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3542         "read and decode the streams to fill missing information with heuristics" },
3543
3544     /* video options */
3545     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_frames },
3546         "set the number of video frames to output", "number" },
3547     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
3548                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_rates) },
3549         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3550     { "s",            OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3551                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_sizes) },
3552         "set frame size (WxH or abbreviation)", "size" },
3553     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
3554                       OPT_OUTPUT,                                                { .off = OFFSET(frame_aspect_ratios) },
3555         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3556     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3557                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_pix_fmts) },
3558         "set pixel format", "format" },
3559     { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG,                      { &frame_bits_per_raw_sample },
3560         "set the number of bits per raw sample", "number" },
3561     { "intra",        OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &intra_only },
3562         "deprecated use -g 1" },
3563     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3564         "disable video" },
3565     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3566                       OPT_OUTPUT,                                                { .off = OFFSET(rc_overrides) },
3567         "rate control override for specific intervals", "override" },
3568     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_INPUT |
3569                       OPT_OUTPUT,                                                { .func_arg = opt_video_codec },
3570         "force video codec ('copy' to copy stream)", "codec" },
3571     { "sameq",        OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
3572         "Removed" },
3573     { "same_quant",   OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
3574         "Removed" },
3575     { "timecode",     OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_timecode },
3576         "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3577     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT,     { .off = OFFSET(pass) },
3578         "select the pass number (1 to 3)", "n" },
3579     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3580                       OPT_OUTPUT,                                                { .off = OFFSET(passlogfiles) },
3581         "select two pass log file name prefix", "prefix" },
3582     { "deinterlace",  OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_deinterlace },
3583         "this option is deprecated, use the yadif filter instead" },
3584     { "psnr",         OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_psnr },
3585         "calculate PSNR of compressed frames" },
3586     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_vstats },
3587         "dump video coding statistics to file" },
3588     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { .func_arg = opt_vstats_file },
3589         "dump video coding statistics to file", "file" },
3590     { "vstats_version",  OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,            { &vstats_version },
3591         "Version of the vstats format to use."},
3592     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_filters },
3593         "set video filters", "filter_graph" },
3594     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3595                       OPT_OUTPUT,                                                { .off = OFFSET(intra_matrices) },
3596         "specify intra matrix coeffs", "matrix" },
3597     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3598                       OPT_OUTPUT,                                                { .off = OFFSET(inter_matrices) },
3599         "specify inter matrix coeffs", "matrix" },
3600     { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3601                       OPT_OUTPUT,                                                { .off = OFFSET(chroma_intra_matrices) },
3602         "specify intra matrix coeffs", "matrix" },
3603     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC |
3604                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(top_field_first) },
3605         "top=1/bottom=0/auto=-1 field first", "" },
3606     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE |
3607                       OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_old2new },
3608         "force video tag/fourcc", "fourcc/tag" },
3609     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
3610         "show QP histogram" },
3611     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC |
3612                       OPT_OUTPUT,                                                { .off = OFFSET(force_fps) },
3613         "force the selected framerate, disable the best supported framerate selection" },
3614     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3615                       OPT_OUTPUT,                                                { .func_arg = opt_streamid },
3616         "set the value of an outfile streamid", "streamIndex:value" },
3617     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3618                           OPT_SPEC | OPT_OUTPUT,                                 { .off = OFFSET(forced_key_frames) },
3619         "force key frames at specified timestamps", "timestamps" },
3620     { "ab",           OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
3621         "audio bitrate (please use -b:a)", "bitrate" },
3622     { "b",            OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
3623         "video bitrate (please use -b:v)", "bitrate" },
3624     { "hwaccel",          OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3625                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccels) },
3626         "use HW accelerated decoding", "hwaccel name" },
3627     { "hwaccel_device",   OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3628                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_devices) },
3629         "select a device for HW acceleration", "devicename" },
3630     { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3631                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_output_formats) },
3632         "select output format used with HW accelerated decoding", "format" },
3633 #if CONFIG_VIDEOTOOLBOX
3634     { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3635 #endif
3636     { "hwaccels",         OPT_EXIT,                                              { .func_arg = show_hwaccels },
3637         "show available HW acceleration methods" },
3638     { "autorotate",       HAS_ARG | OPT_BOOL | OPT_SPEC |
3639                           OPT_EXPERT | OPT_INPUT,                                { .off = OFFSET(autorotate) },
3640         "automatically insert correct rotate filters" },
3641
3642     /* audio options */
3643     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_frames },
3644         "set the number of audio frames to output", "number" },
3645     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_qscale },
3646         "set audio quality (codec-specific)", "quality", },
3647     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
3648                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_sample_rate) },
3649         "set audio sampling rate (in Hz)", "rate" },
3650     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
3651                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_channels) },
3652         "set number of audio channels", "channels" },
3653     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3654         "disable audio" },
3655     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE |
3656                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_audio_codec },
3657         "force audio codec ('copy' to copy stream)", "codec" },
3658     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
3659                         OPT_OUTPUT,                                                { .func_arg = opt_old2new },
3660         "force audio tag/fourcc", "fourcc/tag" },
3661     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
3662         "change audio volume (256=normal)" , "volume" },
3663     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC |
3664                         OPT_STRING | OPT_INPUT | OPT_OUTPUT,                       { .off = OFFSET(sample_fmts) },
3665         "set sample format", "format" },
3666     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
3667                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_channel_layout },
3668         "set channel layout", "layout" },
3669     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_filters },
3670         "set audio filters", "filter_graph" },
3671     { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3672       "set the maximum number of channels to try to guess the channel layout" },
3673
3674     /* subtitle options */
3675     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3676         "disable subtitle" },
3677     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3678         "force subtitle codec ('copy' to copy stream)", "codec" },
3679     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3680         , "force subtitle tag/fourcc", "fourcc/tag" },
3681     { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3682         "fix subtitles duration" },
3683     { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3684         "set canvas size (WxH or abbreviation)", "size" },
3685
3686     /* grab options */
3687     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3688         "deprecated, use -channel", "channel" },
3689     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3690         "deprecated, use -standard", "standard" },
3691     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3692
3693     /* muxer options */
3694     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3695         "set the maximum demux-decode delay", "seconds" },
3696     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3697         "set the initial demux-decode delay", "seconds" },
3698     { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3699         "specify a file in which to print sdp information", "file" },
3700
3701     { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3702         "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3703     { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) },
3704         "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
3705         "two special values are defined - "
3706         "0 = use frame rate (video) or sample rate (audio),"
3707         "-1 = match source time base", "ratio" },
3708
3709     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3710         "A comma-separated list of bitstream filters", "bitstream_filters" },
3711     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3712         "deprecated", "audio bitstream_filters" },
3713     { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3714         "deprecated", "video bitstream_filters" },
3715
3716     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
3717         "set the audio options to the indicated preset", "preset" },
3718     { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
3719         "set the video options to the indicated preset", "preset" },
3720     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3721         "set the subtitle options to the indicated preset", "preset" },
3722     { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,                { .func_arg = opt_preset },
3723         "set options from indicated preset file", "filename" },
3724
3725     { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3726         "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3727
3728     /* data codec support */
3729     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3730         "force data codec ('copy' to copy stream)", "codec" },
3731     { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3732         "disable data" },
3733
3734 #if CONFIG_VAAPI
3735     { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3736         "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3737 #endif
3738
3739 #if CONFIG_QSV
3740     { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3741         "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
3742 #endif
3743
3744     { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
3745         "initialise hardware device", "args" },
3746     { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
3747         "set hardware device used when filtering", "device" },
3748
3749     { NULL, },
3750 };