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