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

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