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