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