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