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