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