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

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