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