git.sesse.net Git - ffmpeg/blob - ffmpeg_opt.c

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