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