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