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

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