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     char *next, *codec_tag = NULL;
 563
 564     for (i = 0; i < ic->nb_streams; i++) {
 565         AVStream *st = ic->streams[i];
 566         AVCodecContext *dec = st->codec;
 567         InputStream *ist = av_mallocz(sizeof(*ist));
 568         char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
 569
 570         if (!ist)
 571             exit_program(1);
 572
 573         GROW_ARRAY(input_streams, nb_input_streams);
 574         input_streams[nb_input_streams - 1] = ist;
 575
 576         ist->st = st;
 577         ist->file_index = nb_input_files;
 578         ist->discard = 1;
 579         st->discard  = AVDISCARD_ALL;
 580
 581         ist->ts_scale = 1.0;
 582         MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
 583
 584         MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
 585         if (codec_tag) {
 586             uint32_t tag = strtol(codec_tag, &next, 0);
 587             if (*next)
 588                 tag = AV_RL32(codec_tag);
 589             st->codec->codec_tag = tag;
 590         }
 591
 592         ist->dec = choose_decoder(o, ic, st);
 593         ist->opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
 594
 595         ist->reinit_filters = -1;
 596         MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
 597
 598         ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
 599
 600         switch (dec->codec_type) {
 601         case AVMEDIA_TYPE_VIDEO:
 602             if(!ist->dec)
 603                 ist->dec = avcodec_find_decoder(dec->codec_id);
 604             if (av_codec_get_lowres(dec)) {
 605                 dec->flags |= CODEC_FLAG_EMU_EDGE;
 606             }
 607
 608             ist->resample_height  = dec->height;
 609             ist->resample_width   = dec->width;
 610             ist->resample_pix_fmt = dec->pix_fmt;
 611
 612             MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
 613             if (framerate && av_parse_video_rate(&ist->framerate,
 614                                                  framerate) < 0) {
 615                 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
 616                        framerate);
 617                 exit_program(1);
 618             }
 619
 620             ist->top_field_first = -1;
 621             MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
 622
 623             MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
 624             if (hwaccel) {
 625                 if (!strcmp(hwaccel, "none"))
 626                     ist->hwaccel_id = HWACCEL_NONE;
 627                 else if (!strcmp(hwaccel, "auto"))
 628                     ist->hwaccel_id = HWACCEL_AUTO;
 629                 else {
 630                     int i;
 631                     for (i = 0; hwaccels[i].name; i++) {
 632                         if (!strcmp(hwaccels[i].name, hwaccel)) {
 633                             ist->hwaccel_id = hwaccels[i].id;
 634                             break;
 635                         }
 636                     }
 637
 638                     if (!ist->hwaccel_id) {
 639                         av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
 640                                hwaccel);
 641                         av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
 642                         for (i = 0; hwaccels[i].name; i++)
 643                             av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
 644                         av_log(NULL, AV_LOG_FATAL, "\n");
 645                         exit_program(1);
 646                     }
 647                 }
 648             }
 649
 650             MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
 651             if (hwaccel_device) {
 652                 ist->hwaccel_device = av_strdup(hwaccel_device);
 653                 if (!ist->hwaccel_device)
 654                     exit_program(1);
 655             }
 656             ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
 657
 658             break;
 659         case AVMEDIA_TYPE_AUDIO:
 660             ist->guess_layout_max = INT_MAX;
 661             MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
 662             guess_input_channel_layout(ist);
 663
 664             ist->resample_sample_fmt     = dec->sample_fmt;
 665             ist->resample_sample_rate    = dec->sample_rate;
 666             ist->resample_channels       = dec->channels;
 667             ist->resample_channel_layout = dec->channel_layout;
 668
 669             break;
 670         case AVMEDIA_TYPE_DATA:
 671         case AVMEDIA_TYPE_SUBTITLE: {
 672             char *canvas_size = NULL;
 673             if(!ist->dec)
 674                 ist->dec = avcodec_find_decoder(dec->codec_id);
 675             MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
 676             MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
 677             if (canvas_size &&
 678                 av_parse_video_size(&dec->width, &dec->height, canvas_size) < 0) {
 679                 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
 680                 exit_program(1);
 681             }
 682             break;
 683         }
 684         case AVMEDIA_TYPE_ATTACHMENT:
 685         case AVMEDIA_TYPE_UNKNOWN:
 686             break;
 687         default:
 688             abort();
 689         }
 690     }
 691 }
 692
 693 static void assert_file_overwrite(const char *filename)
 694 {
 695     if (file_overwrite && no_file_overwrite) {
 696         fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
 697         exit_program(1);
 698     }
 699
 700     if (!file_overwrite &&
 701         (strchr(filename, ':') == NULL || filename[1] == ':' ||
 702          av_strstart(filename, "file:", NULL))) {
 703         if (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; 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) {
 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         int do_pass = 0;
1270         int i;
1271
1272         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1273         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1274             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1275             exit_program(1);
1276         }
1277
1278         video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1279         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1280         if (frame_pix_fmt && *frame_pix_fmt == '+') {
1281             ost->keep_pix_fmt = 1;
1282             if (!*++frame_pix_fmt)
1283                 frame_pix_fmt = NULL;
1284         }
1285         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1286             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1287             exit_program(1);
1288         }
1289         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1290
1291         if (intra_only)
1292             video_enc->gop_size = 0;
1293         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1294         if (intra_matrix) {
1295             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1296                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1297                 exit_program(1);
1298             }
1299             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1300         }
1301         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1302         if (inter_matrix) {
1303             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1304                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1305                 exit_program(1);
1306             }
1307             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1308         }
1309
1310         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1311         for (i = 0; p; i++) {
1312             int start, end, q;
1313             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1314             if (e != 3) {
1315                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1316                 exit_program(1);
1317             }
1318             /* FIXME realloc failure */
1319             video_enc->rc_override =
1320                 av_realloc(video_enc->rc_override,
1321                            sizeof(RcOverride) * (i + 1));
1322             video_enc->rc_override[i].start_frame = start;
1323             video_enc->rc_override[i].end_frame   = end;
1324             if (q > 0) {
1325                 video_enc->rc_override[i].qscale         = q;
1326                 video_enc->rc_override[i].quality_factor = 1.0;
1327             }
1328             else {
1329                 video_enc->rc_override[i].qscale         = 0;
1330                 video_enc->rc_override[i].quality_factor = -q/100.0;
1331             }
1332             p = strchr(p, '/');
1333             if (p) p++;
1334         }
1335         video_enc->rc_override_count = i;
1336         video_enc->intra_dc_precision = intra_dc_precision - 8;
1337
1338         if (do_psnr)
1339             video_enc->flags|= CODEC_FLAG_PSNR;
1340
1341         /* two pass mode */
1342         MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1343         if (do_pass) {
1344             if (do_pass & 1) {
1345                 video_enc->flags |= CODEC_FLAG_PASS1;
1346                 av_dict_set(&ost->opts, "flags", "+pass1", AV_DICT_APPEND);
1347             }
1348             if (do_pass & 2) {
1349                 video_enc->flags |= CODEC_FLAG_PASS2;
1350                 av_dict_set(&ost->opts, "flags", "+pass2", AV_DICT_APPEND);
1351             }
1352         }
1353
1354         MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1355         if (ost->logfile_prefix &&
1356             !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1357             exit_program(1);
1358
1359         MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1360         if (ost->forced_keyframes)
1361             ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1362
1363         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1364
1365         ost->top_field_first = -1;
1366         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1367
1368
1369         ost->avfilter = get_ost_filters(o, oc, ost);
1370         if (!ost->avfilter)
1371             exit_program(1);
1372     } else {
1373         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1374     }
1375
1376     if (ost->stream_copy)
1377         check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1378
1379     return ost;
1380 }
1381
1382 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1383 {
1384     int n;
1385     AVStream *st;
1386     OutputStream *ost;
1387     AVCodecContext *audio_enc;
1388
1389     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1390     st  = ost->st;
1391
1392     audio_enc = st->codec;
1393     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1394
1395     MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1396     MATCH_PER_STREAM_OPT(filters,        str, ost->filters,        oc, st);
1397
1398     if (!ost->stream_copy) {
1399         char *sample_fmt = NULL;
1400
1401         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1402
1403         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1404         if (sample_fmt &&
1405             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1406             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1407             exit_program(1);
1408         }
1409
1410         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1411
1412         MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1413         ost->apad = av_strdup(ost->apad);
1414
1415         ost->avfilter = get_ost_filters(o, oc, ost);
1416         if (!ost->avfilter)
1417             exit_program(1);
1418
1419         /* check for channel mapping for this audio stream */
1420         for (n = 0; n < o->nb_audio_channel_maps; n++) {
1421             AudioChannelMap *map = &o->audio_channel_maps[n];
1422             InputStream *ist = input_streams[ost->source_index];
1423             if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1424                 (map->ofile_idx   == -1 || ost->file_index == map->ofile_idx) &&
1425                 (map->ostream_idx == -1 || ost->st->index  == map->ostream_idx)) {
1426                 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1427                     ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1428                 else
1429                     av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1430                            ost->file_index, ost->st->index);
1431             }
1432         }
1433     }
1434
1435     if (ost->stream_copy)
1436         check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1437
1438     return ost;
1439 }
1440
1441 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1442 {
1443     OutputStream *ost;
1444
1445     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1446     if (!ost->stream_copy) {
1447         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1448         exit_program(1);
1449     }
1450
1451     return ost;
1452 }
1453
1454 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1455 {
1456     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1457     ost->stream_copy = 1;
1458     ost->finished    = 1;
1459     return ost;
1460 }
1461
1462 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1463 {
1464     AVStream *st;
1465     OutputStream *ost;
1466     AVCodecContext *subtitle_enc;
1467
1468     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1469     st  = ost->st;
1470     subtitle_enc = st->codec;
1471
1472     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1473
1474     MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1475
1476     if (!ost->stream_copy) {
1477         char *frame_size = NULL;
1478
1479         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1480         if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1481             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1482             exit_program(1);
1483         }
1484     }
1485
1486     return ost;
1487 }
1488
1489 /* arg format is "output-stream-index:streamid-value". */
1490 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1491 {
1492     OptionsContext *o = optctx;
1493     int idx;
1494     char *p;
1495     char idx_str[16];
1496
1497     av_strlcpy(idx_str, arg, sizeof(idx_str));
1498     p = strchr(idx_str, ':');
1499     if (!p) {
1500         av_log(NULL, AV_LOG_FATAL,
1501                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1502                arg, opt);
1503         exit_program(1);
1504     }
1505     *p++ = '\0';
1506     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1507     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1508     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1509     return 0;
1510 }
1511
1512 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1513 {
1514     AVFormatContext *is = ifile->ctx;
1515     AVFormatContext *os = ofile->ctx;
1516     AVChapter **tmp;
1517     int i;
1518
1519     tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1520     if (!tmp)
1521         return AVERROR(ENOMEM);
1522     os->chapters = tmp;
1523
1524     for (i = 0; i < is->nb_chapters; i++) {
1525         AVChapter *in_ch = is->chapters[i], *out_ch;
1526         int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1527         int64_t ts_off   = av_rescale_q(start_time - ifile->ts_offset,
1528                                        AV_TIME_BASE_Q, in_ch->time_base);
1529         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1530                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1531
1532
1533         if (in_ch->end < ts_off)
1534             continue;
1535         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1536             break;
1537
1538         out_ch = av_mallocz(sizeof(AVChapter));
1539         if (!out_ch)
1540             return AVERROR(ENOMEM);
1541
1542         out_ch->id        = in_ch->id;
1543         out_ch->time_base = in_ch->time_base;
1544         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1545         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1546
1547         if (copy_metadata)
1548             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1549
1550         os->chapters[os->nb_chapters++] = out_ch;
1551     }
1552     return 0;
1553 }
1554
1555 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1556 {
1557     int i, err;
1558     AVFormatContext *ic = avformat_alloc_context();
1559
1560     ic->interrupt_callback = int_cb;
1561     err = avformat_open_input(&ic, filename, NULL, NULL);
1562     if (err < 0)
1563         return err;
1564     /* copy stream format */
1565     for(i=0;i<ic->nb_streams;i++) {
1566         AVStream *st;
1567         OutputStream *ost;
1568         AVCodec *codec;
1569         AVCodecContext *avctx;
1570
1571         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1572         ost   = new_output_stream(o, s, codec->type, -1);
1573         st    = ost->st;
1574         avctx = st->codec;
1575         ost->enc = codec;
1576
1577         // FIXME: a more elegant solution is needed
1578         memcpy(st, ic->streams[i], sizeof(AVStream));
1579         st->cur_dts = 0;
1580         st->info = av_malloc(sizeof(*st->info));
1581         memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1582         st->codec= avctx;
1583         avcodec_copy_context(st->codec, ic->streams[i]->codec);
1584
1585         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1586             choose_sample_fmt(st, codec);
1587         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1588             choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1589     }
1590
1591     avformat_close_input(&ic);
1592     return err;
1593 }
1594
1595 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1596                                AVFormatContext *oc)
1597 {
1598     OutputStream *ost;
1599
1600     switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1601                                   ofilter->out_tmp->pad_idx)) {
1602     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1603     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1604     default:
1605         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1606                "currently.\n");
1607         exit_program(1);
1608     }
1609
1610     ost->source_index = -1;
1611     ost->filter       = ofilter;
1612
1613     ofilter->ost      = ost;
1614
1615     if (ost->stream_copy) {
1616         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1617                "which is fed from a complex filtergraph. Filtering and streamcopy "
1618                "cannot be used together.\n", ost->file_index, ost->index);
1619         exit_program(1);
1620     }
1621
1622     if (ost->avfilter && (ost->filters || ost->filters_script)) {
1623         const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1624         av_log(NULL, AV_LOG_ERROR,
1625                "%s '%s' was specified through the %s option "
1626                "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1627                "%s and -filter_complex cannot be used together for the same stream.\n",
1628                ost->filters ? "Filtergraph" : "Filtergraph script",
1629                ost->filters ? ost->filters : ost->filters_script,
1630                opt, ost->file_index, ost->index, opt);
1631         exit_program(1);
1632     }
1633
1634     if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1635         av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1636         exit_program(1);
1637     }
1638     avfilter_inout_free(&ofilter->out_tmp);
1639 }
1640
1641 static int configure_complex_filters(void)
1642 {
1643     int i, ret = 0;
1644
1645     for (i = 0; i < nb_filtergraphs; i++)
1646         if (!filtergraphs[i]->graph &&
1647             (ret = configure_filtergraph(filtergraphs[i])) < 0)
1648             return ret;
1649     return 0;
1650 }
1651
1652 static int open_output_file(OptionsContext *o, const char *filename)
1653 {
1654     AVFormatContext *oc;
1655     int i, j, err;
1656     AVOutputFormat *file_oformat;
1657     OutputFile *of;
1658     OutputStream *ost;
1659     InputStream  *ist;
1660     AVDictionary *unused_opts = NULL;
1661     AVDictionaryEntry *e = NULL;
1662
1663     if (configure_complex_filters() < 0) {
1664         av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1665         exit_program(1);
1666     }
1667
1668     if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1669         o->stop_time = INT64_MAX;
1670         av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1671     }
1672
1673     if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1674         int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1675         if (o->stop_time <= start_time) {
1676             av_log(NULL, AV_LOG_WARNING, "-to value smaller than -ss; ignoring -to.\n");
1677             o->stop_time = INT64_MAX;
1678         } else {
1679             o->recording_time = o->stop_time - start_time;
1680         }
1681     }
1682
1683     GROW_ARRAY(output_files, nb_output_files);
1684     of = av_mallocz(sizeof(*of));
1685     if (!of)
1686         exit_program(1);
1687     output_files[nb_output_files - 1] = of;
1688
1689     of->ost_index      = nb_output_streams;
1690     of->recording_time = o->recording_time;
1691     of->start_time     = o->start_time;
1692     of->limit_filesize = o->limit_filesize;
1693     of->shortest       = o->shortest;
1694     av_dict_copy(&of->opts, o->g->format_opts, 0);
1695
1696     if (!strcmp(filename, "-"))
1697         filename = "pipe:";
1698
1699     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1700     if (!oc) {
1701         print_error(filename, err);
1702         exit_program(1);
1703     }
1704
1705     of->ctx = oc;
1706     if (o->recording_time != INT64_MAX)
1707         oc->duration = o->recording_time;
1708
1709     file_oformat= oc->oformat;
1710     oc->interrupt_callback = int_cb;
1711
1712     /* create streams for all unlabeled output pads */
1713     for (i = 0; i < nb_filtergraphs; i++) {
1714         FilterGraph *fg = filtergraphs[i];
1715         for (j = 0; j < fg->nb_outputs; j++) {
1716             OutputFilter *ofilter = fg->outputs[j];
1717
1718             if (!ofilter->out_tmp || ofilter->out_tmp->name)
1719                 continue;
1720
1721             switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1722                                           ofilter->out_tmp->pad_idx)) {
1723             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
1724             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
1725             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1726             }
1727             init_output_filter(ofilter, o, oc);
1728         }
1729     }
1730
1731     /* ffserver seeking with date=... needs a date reference */
1732     if (!strcmp(file_oformat->name, "ffm") &&
1733         av_strstart(filename, "http:", NULL)) {
1734         int err = parse_option(o, "metadata", "creation_time=now", options);
1735         if (err < 0) {
1736             print_error(filename, err);
1737             exit_program(1);
1738         }
1739     }
1740
1741     if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1742         av_strstart(filename, "http:", NULL)) {
1743         int j;
1744         /* special case for files sent to ffserver: we get the stream
1745            parameters from ffserver */
1746         int err = read_ffserver_streams(o, oc, filename);
1747         if (err < 0) {
1748             print_error(filename, err);
1749             exit_program(1);
1750         }
1751         for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1752             ost = output_streams[j];
1753             for (i = 0; i < nb_input_streams; i++) {
1754                 ist = input_streams[i];
1755                 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1756                     ost->sync_ist= ist;
1757                     ost->source_index= i;
1758                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1759                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1760                     ist->discard = 0;
1761                     ist->st->discard = AVDISCARD_NONE;
1762                     break;
1763                 }
1764             }
1765             if(!ost->sync_ist){
1766                 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));
1767                 exit_program(1);
1768             }
1769         }
1770     } else if (!o->nb_stream_maps) {
1771         char *subtitle_codec_name = NULL;
1772         /* pick the "best" stream of each type */
1773
1774         /* video: highest resolution */
1775         if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1776             int area = 0, idx = -1;
1777             int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1778             for (i = 0; i < nb_input_streams; i++) {
1779                 int new_area;
1780                 ist = input_streams[i];
1781                 new_area = ist->st->codec->width * ist->st->codec->height;
1782                 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1783                     new_area = 1;
1784                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1785                     new_area > area) {
1786                     if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1787                         continue;
1788                     area = new_area;
1789                     idx = i;
1790                 }
1791             }
1792             if (idx >= 0)
1793                 new_video_stream(o, oc, idx);
1794         }
1795
1796         /* audio: most channels */
1797         if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1798             int channels = 0, idx = -1;
1799             for (i = 0; i < nb_input_streams; i++) {
1800                 ist = input_streams[i];
1801                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1802                     ist->st->codec->channels > channels) {
1803                     channels = ist->st->codec->channels;
1804                     idx = i;
1805                 }
1806             }
1807             if (idx >= 0)
1808                 new_audio_stream(o, oc, idx);
1809         }
1810
1811         /* subtitles: pick first */
1812         MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1813         if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1814             for (i = 0; i < nb_input_streams; i++)
1815                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1816                     new_subtitle_stream(o, oc, i);
1817                     break;
1818                 }
1819         }
1820         /* do something with data? */
1821     } else {
1822         for (i = 0; i < o->nb_stream_maps; i++) {
1823             StreamMap *map = &o->stream_maps[i];
1824
1825             if (map->disabled)
1826                 continue;
1827
1828             if (map->linklabel) {
1829                 FilterGraph *fg;
1830                 OutputFilter *ofilter = NULL;
1831                 int j, k;
1832
1833                 for (j = 0; j < nb_filtergraphs; j++) {
1834                     fg = filtergraphs[j];
1835                     for (k = 0; k < fg->nb_outputs; k++) {
1836                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
1837                         if (out && !strcmp(out->name, map->linklabel)) {
1838                             ofilter = fg->outputs[k];
1839                             goto loop_end;
1840                         }
1841                     }
1842                 }
1843 loop_end:
1844                 if (!ofilter) {
1845                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1846                            "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1847                     exit_program(1);
1848                 }
1849                 init_output_filter(ofilter, o, oc);
1850             } else {
1851                 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1852
1853                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1854                 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1855                     continue;
1856                 if(o->   audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1857                     continue;
1858                 if(o->   video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1859                     continue;
1860                 if(o->    data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1861                     continue;
1862
1863                 switch (ist->st->codec->codec_type) {
1864                 case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
1865                 case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
1866                 case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
1867                 case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
1868                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1869                 default:
1870                     av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1871                            map->file_index, map->stream_index);
1872                     exit_program(1);
1873                 }
1874             }
1875         }
1876     }
1877
1878     /* handle attached files */
1879     for (i = 0; i < o->nb_attachments; i++) {
1880         AVIOContext *pb;
1881         uint8_t *attachment;
1882         const char *p;
1883         int64_t len;
1884
1885         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1886             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1887                    o->attachments[i]);
1888             exit_program(1);
1889         }
1890         if ((len = avio_size(pb)) <= 0) {
1891             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1892                    o->attachments[i]);
1893             exit_program(1);
1894         }
1895         if (!(attachment = av_malloc(len))) {
1896             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1897                    o->attachments[i]);
1898             exit_program(1);
1899         }
1900         avio_read(pb, attachment, len);
1901
1902         ost = new_attachment_stream(o, oc, -1);
1903         ost->stream_copy               = 0;
1904         ost->attachment_filename       = o->attachments[i];
1905         ost->finished                  = 1;
1906         ost->st->codec->extradata      = attachment;
1907         ost->st->codec->extradata_size = len;
1908
1909         p = strrchr(o->attachments[i], '/');
1910         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1911         avio_close(pb);
1912     }
1913
1914     for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1915         AVDictionaryEntry *e;
1916         ost = output_streams[i];
1917
1918         if ((ost->stream_copy || ost->attachment_filename)
1919             && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1920             && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1921             if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1922                 exit_program(1);
1923     }
1924
1925     /* check if all codec options have been used */
1926     unused_opts = strip_specifiers(o->g->codec_opts);
1927     for (i = of->ost_index; i < nb_output_streams; i++) {
1928         e = NULL;
1929         while ((e = av_dict_get(output_streams[i]->opts, "", e,
1930                                 AV_DICT_IGNORE_SUFFIX)))
1931             av_dict_set(&unused_opts, e->key, NULL, 0);
1932     }
1933
1934     e = NULL;
1935     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1936         const AVClass *class = avcodec_get_class();
1937         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1938                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1939         if (!option)
1940             continue;
1941         if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1942             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1943                    "output file #%d (%s) is not an encoding option.\n", e->key,
1944                    option->help ? option->help : "", nb_output_files - 1,
1945                    filename);
1946             exit_program(1);
1947         }
1948
1949         // gop_timecode is injected by generic code but not always used
1950         if (!strcmp(e->key, "gop_timecode"))
1951             continue;
1952
1953         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1954                "output file #%d (%s) has not been used for any stream. The most "
1955                "likely reason is either wrong type (e.g. a video option with "
1956                "no video streams) or that it is a private option of some encoder "
1957                "which was not actually used for any stream.\n", e->key,
1958                option->help ? option->help : "", nb_output_files - 1, filename);
1959     }
1960     av_dict_free(&unused_opts);
1961
1962     /* check filename in case of an image number is expected */
1963     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1964         if (!av_filename_number_test(oc->filename)) {
1965             print_error(oc->filename, AVERROR(EINVAL));
1966             exit_program(1);
1967         }
1968     }
1969
1970     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1971         /* test if it already exists to avoid losing precious files */
1972         assert_file_overwrite(filename);
1973
1974         /* open the file */
1975         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1976                               &oc->interrupt_callback,
1977                               &of->opts)) < 0) {
1978             print_error(filename, err);
1979             exit_program(1);
1980         }
1981     } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
1982         assert_file_overwrite(filename);
1983
1984     if (o->mux_preload) {
1985         uint8_t buf[64];
1986         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1987         av_dict_set(&of->opts, "preload", buf, 0);
1988     }
1989     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1990
1991     /* copy metadata */
1992     for (i = 0; i < o->nb_metadata_map; i++) {
1993         char *p;
1994         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1995
1996         if (in_file_index >= nb_input_files) {
1997             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1998             exit_program(1);
1999         }
2000         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2001                       in_file_index >= 0 ?
2002                       input_files[in_file_index]->ctx : NULL, o);
2003     }
2004
2005     /* copy chapters */
2006     if (o->chapters_input_file >= nb_input_files) {
2007         if (o->chapters_input_file == INT_MAX) {
2008             /* copy chapters from the first input file that has them*/
2009             o->chapters_input_file = -1;
2010             for (i = 0; i < nb_input_files; i++)
2011                 if (input_files[i]->ctx->nb_chapters) {
2012                     o->chapters_input_file = i;
2013                     break;
2014                 }
2015         } else {
2016             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2017                    o->chapters_input_file);
2018             exit_program(1);
2019         }
2020     }
2021     if (o->chapters_input_file >= 0)
2022         copy_chapters(input_files[o->chapters_input_file], of,
2023                       !o->metadata_chapters_manual);
2024
2025     /* copy global metadata by default */
2026     if (!o->metadata_global_manual && nb_input_files){
2027         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2028                      AV_DICT_DONT_OVERWRITE);
2029         if(o->recording_time != INT64_MAX)
2030             av_dict_set(&oc->metadata, "duration", NULL, 0);
2031         av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2032     }
2033     if (!o->metadata_streams_manual)
2034         for (i = of->ost_index; i < nb_output_streams; i++) {
2035             InputStream *ist;
2036             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
2037                 continue;
2038             ist = input_streams[output_streams[i]->source_index];
2039             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2040         }
2041
2042     /* process manually set metadata */
2043     for (i = 0; i < o->nb_metadata; i++) {
2044         AVDictionary **m;
2045         char type, *val;
2046         const char *stream_spec;
2047         int index = 0, j, ret = 0;
2048
2049         val = strchr(o->metadata[i].u.str, '=');
2050         if (!val) {
2051             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2052                    o->metadata[i].u.str);
2053             exit_program(1);
2054         }
2055         *val++ = 0;
2056
2057         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2058         if (type == 's') {
2059             for (j = 0; j < oc->nb_streams; j++) {
2060                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2061                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2062                 } else if (ret < 0)
2063                     exit_program(1);
2064             }
2065         }
2066         else {
2067             switch (type) {
2068             case 'g':
2069                 m = &oc->metadata;
2070                 break;
2071             case 'c':
2072                 if (index < 0 || index >= oc->nb_chapters) {
2073                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2074                     exit_program(1);
2075                 }
2076                 m = &oc->chapters[index]->metadata;
2077                 break;
2078             default:
2079                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2080                 exit_program(1);
2081             }
2082             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2083         }
2084     }
2085
2086     return 0;
2087 }
2088
2089 static int opt_target(void *optctx, const char *opt, const char *arg)
2090 {
2091     OptionsContext *o = optctx;
2092     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2093     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2094
2095     if (!strncmp(arg, "pal-", 4)) {
2096         norm = PAL;
2097         arg += 4;
2098     } else if (!strncmp(arg, "ntsc-", 5)) {
2099         norm = NTSC;
2100         arg += 5;
2101     } else if (!strncmp(arg, "film-", 5)) {
2102         norm = FILM;
2103         arg += 5;
2104     } else {
2105         /* Try to determine PAL/NTSC by peeking in the input files */
2106         if (nb_input_files) {
2107             int i, j, fr;
2108             for (j = 0; j < nb_input_files; j++) {
2109                 for (i = 0; i < input_files[j]->nb_streams; i++) {
2110                     AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2111                     if (c->codec_type != AVMEDIA_TYPE_VIDEO)
2112                         continue;
2113                     fr = c->time_base.den * 1000 / c->time_base.num;
2114                     if (fr == 25000) {
2115                         norm = PAL;
2116                         break;
2117                     } else if ((fr == 29970) || (fr == 23976)) {
2118                         norm = NTSC;
2119                         break;
2120                     }
2121                 }
2122                 if (norm != UNKNOWN)
2123                     break;
2124             }
2125         }
2126         if (norm != UNKNOWN)
2127             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2128     }
2129
2130     if (norm == UNKNOWN) {
2131         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2132         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2133         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2134         exit_program(1);
2135     }
2136
2137     if (!strcmp(arg, "vcd")) {
2138         opt_video_codec(o, "c:v", "mpeg1video");
2139         opt_audio_codec(o, "c:a", "mp2");
2140         parse_option(o, "f", "vcd", options);
2141
2142         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2143         parse_option(o, "r", frame_rates[norm], options);
2144         av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2145
2146         av_dict_set(&o->g->codec_opts, "b:v", "1150000", AV_DICT_DONT_OVERWRITE);
2147         av_dict_set(&o->g->codec_opts, "maxrate", "1150000", AV_DICT_DONT_OVERWRITE);
2148         av_dict_set(&o->g->codec_opts, "minrate", "1150000", AV_DICT_DONT_OVERWRITE);
2149         av_dict_set(&o->g->codec_opts, "bufsize", "327680", AV_DICT_DONT_OVERWRITE); // 40*1024*8;
2150
2151         av_dict_set(&o->g->codec_opts, "b:a", "224000", AV_DICT_DONT_OVERWRITE);
2152         parse_option(o, "ar", "44100", options);
2153         parse_option(o, "ac", "2", options);
2154
2155         av_dict_set(&o->g->format_opts, "packetsize", "2324", AV_DICT_DONT_OVERWRITE);
2156         av_dict_set(&o->g->format_opts, "muxrate", "1411200", AV_DICT_DONT_OVERWRITE); // 2352 * 75 * 8;
2157
2158         /* We have to offset the PTS, so that it is consistent with the SCR.
2159            SCR starts at 36000, but the first two packs contain only padding
2160            and the first pack from the other stream, respectively, may also have
2161            been written before.
2162            So the real data starts at SCR 36000+3*1200. */
2163         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2164     } else if (!strcmp(arg, "svcd")) {
2165
2166         opt_video_codec(o, "c:v", "mpeg2video");
2167         opt_audio_codec(o, "c:a", "mp2");
2168         parse_option(o, "f", "svcd", options);
2169
2170         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2171         parse_option(o, "r", frame_rates[norm], options);
2172         parse_option(o, "pix_fmt", "yuv420p", options);
2173         av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2174
2175         av_dict_set(&o->g->codec_opts, "b:v", "2040000", AV_DICT_DONT_OVERWRITE);
2176         av_dict_set(&o->g->codec_opts, "maxrate", "2516000", AV_DICT_DONT_OVERWRITE);
2177         av_dict_set(&o->g->codec_opts, "minrate", "0", AV_DICT_DONT_OVERWRITE); // 1145000;
2178         av_dict_set(&o->g->codec_opts, "bufsize", "1835008", AV_DICT_DONT_OVERWRITE); // 224*1024*8;
2179         av_dict_set(&o->g->codec_opts, "scan_offset", "1", AV_DICT_DONT_OVERWRITE);
2180
2181         av_dict_set(&o->g->codec_opts, "b:a", "224000", AV_DICT_DONT_OVERWRITE);
2182         parse_option(o, "ar", "44100", options);
2183
2184         av_dict_set(&o->g->format_opts, "packetsize", "2324", AV_DICT_DONT_OVERWRITE);
2185
2186     } else if (!strcmp(arg, "dvd")) {
2187
2188         opt_video_codec(o, "c:v", "mpeg2video");
2189         opt_audio_codec(o, "c:a", "ac3");
2190         parse_option(o, "f", "dvd", options);
2191
2192         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2193         parse_option(o, "r", frame_rates[norm], options);
2194         parse_option(o, "pix_fmt", "yuv420p", options);
2195         av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2196
2197         av_dict_set(&o->g->codec_opts, "b:v", "6000000", AV_DICT_DONT_OVERWRITE);
2198         av_dict_set(&o->g->codec_opts, "maxrate", "9000000", AV_DICT_DONT_OVERWRITE);
2199         av_dict_set(&o->g->codec_opts, "minrate", "0", AV_DICT_DONT_OVERWRITE); // 1500000;
2200         av_dict_set(&o->g->codec_opts, "bufsize", "1835008", AV_DICT_DONT_OVERWRITE); // 224*1024*8;
2201
2202         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.
2203         av_dict_set(&o->g->format_opts, "muxrate", "10080000", AV_DICT_DONT_OVERWRITE); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2204
2205         av_dict_set(&o->g->codec_opts, "b:a", "448000", AV_DICT_DONT_OVERWRITE);
2206         parse_option(o, "ar", "48000", options);
2207
2208     } else if (!strncmp(arg, "dv", 2)) {
2209
2210         parse_option(o, "f", "dv", options);
2211
2212         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2213         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2214                           norm == PAL ? "yuv420p" : "yuv411p", options);
2215         parse_option(o, "r", frame_rates[norm], options);
2216
2217         parse_option(o, "ar", "48000", options);
2218         parse_option(o, "ac", "2", options);
2219
2220     } else {
2221         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2222         return AVERROR(EINVAL);
2223     }
2224     return 0;
2225 }
2226
2227 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2228 {
2229     av_free (vstats_filename);
2230     vstats_filename = av_strdup (arg);
2231     return 0;
2232 }
2233
2234 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2235 {
2236     char filename[40];
2237     time_t today2 = time(NULL);
2238     struct tm *today = localtime(&today2);
2239
2240     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2241              today->tm_sec);
2242     return opt_vstats_file(NULL, opt, filename);
2243 }
2244
2245 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2246 {
2247     OptionsContext *o = optctx;
2248     return parse_option(o, "frames:v", arg, options);
2249 }
2250
2251 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2252 {
2253     OptionsContext *o = optctx;
2254     return parse_option(o, "frames:a", arg, options);
2255 }
2256
2257 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2258 {
2259     OptionsContext *o = optctx;
2260     return parse_option(o, "frames:d", arg, options);
2261 }
2262
2263 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2264 {
2265     int ret;
2266     AVDictionary *cbak = codec_opts;
2267     AVDictionary *fbak = format_opts;
2268     codec_opts = NULL;
2269     format_opts = NULL;
2270
2271     ret = opt_default(NULL, opt, arg);
2272
2273     av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2274     av_dict_copy(&o->g->format_opts, format_opts, 0);
2275     av_dict_free(&codec_opts);
2276     av_dict_free(&format_opts);
2277     codec_opts = cbak;
2278     format_opts = fbak;
2279
2280     return ret;
2281 }
2282
2283 static int opt_preset(void *optctx, const char *opt, const char *arg)
2284 {
2285     OptionsContext *o = optctx;
2286     FILE *f=NULL;
2287     char filename[1000], line[1000], tmp_line[1000];
2288     const char *codec_name = NULL;
2289
2290     tmp_line[0] = *opt;
2291     tmp_line[1] = 0;
2292     MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2293
2294     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2295         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2296             av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2297         }else
2298             av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2299         exit_program(1);
2300     }
2301
2302     while (fgets(line, sizeof(line), f)) {
2303         char *key = tmp_line, *value, *endptr;
2304
2305         if (strcspn(line, "#\n\r") == 0)
2306             continue;
2307         av_strlcpy(tmp_line, line, sizeof(tmp_line));
2308         if (!av_strtok(key,   "=",    &value) ||
2309             !av_strtok(value, "\r\n", &endptr)) {
2310             av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2311             exit_program(1);
2312         }
2313         av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2314
2315         if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
2316         else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
2317         else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2318         else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
2319         else if (opt_default_new(o, key, value) < 0) {
2320             av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2321                    filename, line, key, value);
2322             exit_program(1);
2323         }
2324     }
2325
2326     fclose(f);
2327
2328     return 0;
2329 }
2330
2331 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2332 {
2333     OptionsContext *o = optctx;
2334     char *s = av_asprintf("%s:%c", opt + 1, *opt);
2335     int ret = parse_option(o, s, arg, options);
2336     av_free(s);
2337     return ret;
2338 }
2339
2340 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2341 {
2342     OptionsContext *o = optctx;
2343     if(!strcmp(opt, "b")){
2344         av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2345         av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2346         return 0;
2347     }
2348     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2349     return 0;
2350 }
2351
2352 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2353 {
2354     OptionsContext *o = optctx;
2355     char *s;
2356     int ret;
2357     if(!strcmp(opt, "qscale")){
2358         av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2359         return parse_option(o, "q:v", arg, options);
2360     }
2361     s = av_asprintf("q%s", opt + 6);
2362     ret = parse_option(o, s, arg, options);
2363     av_free(s);
2364     return ret;
2365 }
2366
2367 static int opt_profile(void *optctx, const char *opt, const char *arg)
2368 {
2369     OptionsContext *o = optctx;
2370     if(!strcmp(opt, "profile")){
2371         av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2372         av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2373         return 0;
2374     }
2375     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2376     return 0;
2377 }
2378
2379 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2380 {
2381     OptionsContext *o = optctx;
2382     return parse_option(o, "filter:v", arg, options);
2383 }
2384
2385 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2386 {
2387     OptionsContext *o = optctx;
2388     return parse_option(o, "filter:a", arg, options);
2389 }
2390
2391 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2392 {
2393     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
2394     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
2395     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2396     else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
2397
2398     if (video_sync_method == VSYNC_AUTO)
2399         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2400     return 0;
2401 }
2402
2403 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2404 {
2405     OptionsContext *o = optctx;
2406     char *tcr = av_asprintf("timecode=%s", arg);
2407     int ret = parse_option(o, "metadata:g", tcr, options);
2408     if (ret >= 0)
2409         ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2410     av_free(tcr);
2411     return 0;
2412 }
2413
2414 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2415 {
2416     OptionsContext *o = optctx;
2417     char layout_str[32];
2418     char *stream_str;
2419     char *ac_str;
2420     int ret, channels, ac_str_size;
2421     uint64_t layout;
2422
2423     layout = av_get_channel_layout(arg);
2424     if (!layout) {
2425         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2426         return AVERROR(EINVAL);
2427     }
2428     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2429     ret = opt_default_new(o, opt, layout_str);
2430     if (ret < 0)
2431         return ret;
2432
2433     /* set 'ac' option based on channel layout */
2434     channels = av_get_channel_layout_nb_channels(layout);
2435     snprintf(layout_str, sizeof(layout_str), "%d", channels);
2436     stream_str = strchr(opt, ':');
2437     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2438     ac_str = av_mallocz(ac_str_size);
2439     if (!ac_str)
2440         return AVERROR(ENOMEM);
2441     av_strlcpy(ac_str, "ac", 3);
2442     if (stream_str)
2443         av_strlcat(ac_str, stream_str, ac_str_size);
2444     ret = parse_option(o, ac_str, layout_str, options);
2445     av_free(ac_str);
2446
2447     return ret;
2448 }
2449
2450 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2451 {
2452     OptionsContext *o = optctx;
2453     return parse_option(o, "q:a", arg, options);
2454 }
2455
2456 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2457 {
2458     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2459     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2460         return AVERROR(ENOMEM);
2461     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2462     filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2463     if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2464         return AVERROR(ENOMEM);
2465     return 0;
2466 }
2467
2468 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2469 {
2470     uint8_t *graph_desc = read_file(arg);
2471     if (!graph_desc)
2472         return AVERROR(EINVAL);
2473
2474     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2475     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2476         return AVERROR(ENOMEM);
2477     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2478     filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2479     return 0;
2480 }
2481
2482 void show_help_default(const char *opt, const char *arg)
2483 {
2484     /* per-file options have at least one of those set */
2485     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2486     int show_advanced = 0, show_avoptions = 0;
2487
2488     if (opt && *opt) {
2489         if (!strcmp(opt, "long"))
2490             show_advanced = 1;
2491         else if (!strcmp(opt, "full"))
2492             show_advanced = show_avoptions = 1;
2493         else
2494             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2495     }
2496
2497     show_usage();
2498
2499     printf("Getting help:\n"
2500            "    -h      -- print basic options\n"
2501            "    -h long -- print more options\n"
2502            "    -h full -- print all options (including all format and codec specific options, very long)\n"
2503            "    See man %s for detailed description of the options.\n"
2504            "\n", program_name);
2505
2506     show_help_options(options, "Print help / information / capabilities:",
2507                       OPT_EXIT, 0, 0);
2508
2509     show_help_options(options, "Global options (affect whole program "
2510                       "instead of just one file:",
2511                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2512     if (show_advanced)
2513         show_help_options(options, "Advanced global options:", OPT_EXPERT,
2514                           per_file | OPT_EXIT, 0);
2515
2516     show_help_options(options, "Per-file main options:", 0,
2517                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2518                       OPT_EXIT, per_file);
2519     if (show_advanced)
2520         show_help_options(options, "Advanced per-file options:",
2521                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2522
2523     show_help_options(options, "Video options:",
2524                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2525     if (show_advanced)
2526         show_help_options(options, "Advanced Video options:",
2527                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2528
2529     show_help_options(options, "Audio options:",
2530                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2531     if (show_advanced)
2532         show_help_options(options, "Advanced Audio options:",
2533                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2534     show_help_options(options, "Subtitle options:",
2535                       OPT_SUBTITLE, 0, 0);
2536     printf("\n");
2537
2538     if (show_avoptions) {
2539         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2540         show_help_children(avcodec_get_class(), flags);
2541         show_help_children(avformat_get_class(), flags);
2542 #if CONFIG_SWSCALE
2543         show_help_children(sws_get_class(), flags);
2544 #endif
2545         show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2546         show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2547     }
2548 }
2549
2550 void show_usage(void)
2551 {
2552     av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2553     av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2554     av_log(NULL, AV_LOG_INFO, "\n");
2555 }
2556
2557 enum OptGroup {
2558     GROUP_OUTFILE,
2559     GROUP_INFILE,
2560 };
2561
2562 static const OptionGroupDef groups[] = {
2563     [GROUP_OUTFILE] = { "output file",  NULL, OPT_OUTPUT },
2564     [GROUP_INFILE]  = { "input file",   "i",  OPT_INPUT },
2565 };
2566
2567 static int open_files(OptionGroupList *l, const char *inout,
2568                       int (*open_file)(OptionsContext*, const char*))
2569 {
2570     int i, ret;
2571
2572     for (i = 0; i < l->nb_groups; i++) {
2573         OptionGroup *g = &l->groups[i];
2574         OptionsContext o;
2575
2576         init_options(&o);
2577         o.g = g;
2578
2579         ret = parse_optgroup(&o, g);
2580         if (ret < 0) {
2581             av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2582                    "%s.\n", inout, g->arg);
2583             return ret;
2584         }
2585
2586         av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2587         ret = open_file(&o, g->arg);
2588         uninit_options(&o);
2589         if (ret < 0) {
2590             av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2591                    inout, g->arg);
2592             return ret;
2593         }
2594         av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2595     }
2596
2597     return 0;
2598 }
2599
2600 int ffmpeg_parse_options(int argc, char **argv)
2601 {
2602     OptionParseContext octx;
2603     uint8_t error[128];
2604     int ret;
2605
2606     memset(&octx, 0, sizeof(octx));
2607
2608     /* split the commandline into an internal representation */
2609     ret = split_commandline(&octx, argc, argv, options, groups,
2610                             FF_ARRAY_ELEMS(groups));
2611     if (ret < 0) {
2612         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2613         goto fail;
2614     }
2615
2616     /* apply global options */
2617     ret = parse_optgroup(NULL, &octx.global_opts);
2618     if (ret < 0) {
2619         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2620         goto fail;
2621     }
2622
2623     /* open input files */
2624     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2625     if (ret < 0) {
2626         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2627         goto fail;
2628     }
2629
2630     /* open output files */
2631     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2632     if (ret < 0) {
2633         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2634         goto fail;
2635     }
2636
2637 fail:
2638     uninit_parse_context(&octx);
2639     if (ret < 0) {
2640         av_strerror(ret, error, sizeof(error));
2641         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2642     }
2643     return ret;
2644 }
2645
2646 static int opt_progress(void *optctx, const char *opt, const char *arg)
2647 {
2648     AVIOContext *avio = NULL;
2649     int ret;
2650
2651     if (!strcmp(arg, "-"))
2652         arg = "pipe:";
2653     ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2654     if (ret < 0) {
2655         av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2656                arg, av_err2str(ret));
2657         return ret;
2658     }
2659     progress_avio = avio;
2660     return 0;
2661 }
2662
2663 #define OFFSET(x) offsetof(OptionsContext, x)
2664 const OptionDef options[] = {
2665     /* main options */
2666 #include "cmdutils_common_opts.h"
2667     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET |
2668                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(format) },
2669         "force format", "fmt" },
2670     { "y",              OPT_BOOL,                                    {              &file_overwrite },
2671         "overwrite output files" },
2672     { "n",              OPT_BOOL,                                    {              &no_file_overwrite },
2673         "never overwrite output files" },
2674     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC |
2675                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2676         "codec name", "codec" },
2677     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC |
2678                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2679         "codec name", "codec" },
2680     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC |
2681                         OPT_OUTPUT,                                  { .off       = OFFSET(presets) },
2682         "preset name", "preset" },
2683     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2684                         OPT_OUTPUT,                                  { .func_arg = opt_map },
2685         "set input stream mapping",
2686         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2687     { "map_channel",    HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2688         "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2689     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC |
2690                         OPT_OUTPUT,                                  { .off       = OFFSET(metadata_map) },
2691         "set metadata information of outfile from infile",
2692         "outfile[,metadata]:infile[,metadata]" },
2693     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2694                         OPT_OUTPUT,                                  { .off = OFFSET(chapters_input_file) },
2695         "set chapters mapping", "input_file_index" },
2696     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET |
2697                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(recording_time) },
2698         "record or transcode \"duration\" seconds of audio/video",
2699         "duration" },
2700     { "to",             HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT,  { .off = OFFSET(stop_time) },
2701         "record or transcode stop time", "time_stop" },
2702     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2703         "set the limit file size in bytes", "limit_size" },
2704     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET |
2705                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time) },
2706         "set the start time offset", "time_off" },
2707     { "accurate_seek",  OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2708                         OPT_INPUT,                                   { .off = OFFSET(accurate_seek) },
2709         "enable/disable accurate seeking with -ss" },
2710     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET |
2711                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(input_ts_offset) },
2712         "set the input ts offset", "time_off" },
2713     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2714                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(ts_scale) },
2715         "set the input ts scale", "scale" },
2716     { "timestamp",      HAS_ARG | OPT_PERFILE,                       { .func_arg = opt_recording_timestamp },
2717         "set the recording timestamp ('now' to set the current time)", "time" },
2718     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2719         "add metadata", "string=string" },
2720     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2721                         OPT_OUTPUT,                                  { .func_arg = opt_data_frames },
2722         "set the number of data frames to record", "number" },
2723     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
2724         "add timings for benchmarking" },
2725     { "benchmark_all",  OPT_BOOL | OPT_EXPERT,                       { &do_benchmark_all },
2726       "add timings for each task" },
2727     { "progress",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_progress },
2728       "write program-readable progress information", "url" },
2729     { "stdin",          OPT_BOOL | OPT_EXPERT,                       { &stdin_interaction },
2730       "enable or disable interaction on standard input" },
2731     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
2732         "set max runtime in seconds", "limit" },
2733     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
2734         "dump each input packet" },
2735     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
2736         "when dumping packets, also dump the payload" },
2737     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2738                         OPT_INPUT,                                   { .off = OFFSET(rate_emu) },
2739         "read input at native frame rate", "" },
2740     { "target",         HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_target },
2741         "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2742         " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2743     { "vsync",          HAS_ARG | OPT_EXPERT,                        { opt_vsync },
2744         "video sync method", "" },
2745     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
2746         "audio sync method", "" },
2747     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
2748         "audio drift threshold", "threshold" },
2749     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
2750         "copy timestamps" },
2751     { "copytb",         HAS_ARG | OPT_INT | OPT_EXPERT,              { &copy_tb },
2752         "copy input stream time base when stream copying", "mode" },
2753     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2754                         OPT_OUTPUT,                                  { .off = OFFSET(shortest) },
2755         "finish encoding within shortest input" },
2756     { "apad",           OPT_STRING | HAS_ARG | OPT_SPEC |
2757                         OPT_OUTPUT,                                  { .off = OFFSET(apad) },
2758         "audio pad", "" },
2759     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
2760         "timestamp discontinuity delta threshold", "threshold" },
2761     { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_error_threshold },
2762         "timestamp error delta threshold", "threshold" },
2763     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
2764         "exit on error", "error" },
2765     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2766                         OPT_OUTPUT,                                  { .off = OFFSET(copy_initial_nonkeyframes) },
2767         "copy initial non-keyframes" },
2768     { "copypriorss",    OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,   { .off = OFFSET(copy_prior_start) },
2769         "copy or discard frames before start time" },
2770     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2771         "set the number of frames to record", "number" },
2772     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC |
2773                         OPT_EXPERT | OPT_OUTPUT,                     { .off = OFFSET(codec_tags) },
2774         "force codec tag/fourcc", "fourcc/tag" },
2775     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2776                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
2777         "use fixed quality scale (VBR)", "q" },
2778     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2779                         OPT_OUTPUT,                                  { .func_arg = opt_qscale },
2780         "use fixed quality scale (VBR)", "q" },
2781     { "profile",        HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2782         "set profile", "profile" },
2783     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2784         "set stream filtergraph", "filter_graph" },
2785     { "filter_script",  HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2786         "read stream filtergraph description from a file", "filename" },
2787     { "reinit_filter",  HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT,    { .off = OFFSET(reinit_filters) },
2788         "reinit filtergraph on input parameter changes", "" },
2789     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
2790         "create a complex filtergraph", "graph_description" },
2791     { "lavfi",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
2792         "create a complex filtergraph", "graph_description" },
2793     { "filter_complex_script", HAS_ARG | OPT_EXPERT,                 { .func_arg = opt_filter_complex_script },
2794         "read complex filtergraph description from a file", "filename" },
2795     { "stats",          OPT_BOOL,                                    { &print_stats },
2796         "print progress report during encoding", },
2797     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2798                         OPT_OUTPUT,                                  { .func_arg = opt_attach },
2799         "add an attachment to the output file", "filename" },
2800     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2801                          OPT_EXPERT | OPT_INPUT,                     { .off = OFFSET(dump_attachment) },
2802         "extract an attachment into a file", "filename" },
2803     { "debug_ts",       OPT_BOOL | OPT_EXPERT,                       { &debug_ts },
2804         "print timestamp debugging info" },
2805     { "max_error_rate",  HAS_ARG | OPT_FLOAT,                        { &max_error_rate },
2806         "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
2807
2808     /* video options */
2809     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_frames },
2810         "set the number of video frames to record", "number" },
2811     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2812                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_rates) },
2813         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2814     { "s",            OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2815                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_sizes) },
2816         "set frame size (WxH or abbreviation)", "size" },
2817     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2818                       OPT_OUTPUT,                                                { .off = OFFSET(frame_aspect_ratios) },
2819         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2820     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2821                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_pix_fmts) },
2822         "set pixel format", "format" },
2823     { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG,                      { &frame_bits_per_raw_sample },
2824         "set the number of bits per raw sample", "number" },
2825     { "intra",        OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &intra_only },
2826         "deprecated use -g 1" },
2827     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2828         "disable video" },
2829     { "vdt",          OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &video_discard },
2830         "discard threshold", "n" },
2831     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2832                       OPT_OUTPUT,                                                { .off = OFFSET(rc_overrides) },
2833         "rate control override for specific intervals", "override" },
2834     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_INPUT |
2835                       OPT_OUTPUT,                                                { .func_arg = opt_video_codec },
2836         "force video codec ('copy' to copy stream)", "codec" },
2837     { "sameq",        OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
2838         "Removed" },
2839     { "same_quant",   OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
2840         "Removed" },
2841     { "timecode",     OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_timecode },
2842         "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2843     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT,     { .off = OFFSET(pass) },
2844         "select the pass number (1 to 3)", "n" },
2845     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2846                       OPT_OUTPUT,                                                { .off = OFFSET(passlogfiles) },
2847         "select two pass log file name prefix", "prefix" },
2848     { "deinterlace",  OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_deinterlace },
2849         "this option is deprecated, use the yadif filter instead" },
2850     { "psnr",         OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_psnr },
2851         "calculate PSNR of compressed frames" },
2852     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { &opt_vstats },
2853         "dump video coding statistics to file" },
2854     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { opt_vstats_file },
2855         "dump video coding statistics to file", "file" },
2856     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_filters },
2857         "set video filters", "filter_graph" },
2858     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2859                       OPT_OUTPUT,                                                { .off = OFFSET(intra_matrices) },
2860         "specify intra matrix coeffs", "matrix" },
2861     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2862                       OPT_OUTPUT,                                                { .off = OFFSET(inter_matrices) },
2863         "specify inter matrix coeffs", "matrix" },
2864     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC |
2865                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(top_field_first) },
2866         "top=1/bottom=0/auto=-1 field first", "" },
2867     { "dc",           OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &intra_dc_precision },
2868         "intra_dc_precision", "precision" },
2869     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE |
2870                       OPT_OUTPUT,                                                { .func_arg = opt_old2new },
2871         "force video tag/fourcc", "fourcc/tag" },
2872     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
2873         "show QP histogram" },
2874     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC |
2875                       OPT_OUTPUT,                                                { .off = OFFSET(force_fps) },
2876         "force the selected framerate, disable the best supported framerate selection" },
2877     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2878                       OPT_OUTPUT,                                                { .func_arg = opt_streamid },
2879         "set the value of an outfile streamid", "streamIndex:value" },
2880     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2881                           OPT_SPEC | OPT_OUTPUT,                                 { .off = OFFSET(forced_key_frames) },
2882         "force key frames at specified timestamps", "timestamps" },
2883     { "b",            OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
2884         "video bitrate (please use -b:v)", "bitrate" },
2885     { "hwaccel",          OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2886                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccels) },
2887         "use HW accelerated decoding", "hwaccel name" },
2888     { "hwaccel_device",   OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2889                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_devices) },
2890         "select a device for HW acceleration" "devicename" },
2891
2892     /* audio options */
2893     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_frames },
2894         "set the number of audio frames to record", "number" },
2895     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_qscale },
2896         "set audio quality (codec-specific)", "quality", },
2897     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
2898                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_sample_rate) },
2899         "set audio sampling rate (in Hz)", "rate" },
2900     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
2901                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_channels) },
2902         "set number of audio channels", "channels" },
2903     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
2904         "disable audio" },
2905     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE |
2906                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_audio_codec },
2907         "force audio codec ('copy' to copy stream)", "codec" },
2908     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
2909                         OPT_OUTPUT,                                                { .func_arg = opt_old2new },
2910         "force audio tag/fourcc", "fourcc/tag" },
2911     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
2912         "change audio volume (256=normal)" , "volume" },
2913     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC |
2914                         OPT_STRING | OPT_INPUT | OPT_OUTPUT,                       { .off = OFFSET(sample_fmts) },
2915         "set sample format", "format" },
2916     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
2917                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_channel_layout },
2918         "set channel layout", "layout" },
2919     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_filters },
2920         "set audio filters", "filter_graph" },
2921     { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
2922       "set the maximum number of channels to try to guess the channel layout" },
2923
2924     /* subtitle options */
2925     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2926         "disable subtitle" },
2927     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2928         "force subtitle codec ('copy' to copy stream)", "codec" },
2929     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
2930         , "force subtitle tag/fourcc", "fourcc/tag" },
2931     { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
2932         "fix subtitles duration" },
2933     { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
2934         "set canvas size (WxH or abbreviation)", "size" },
2935
2936     /* grab options */
2937     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2938         "deprecated, use -channel", "channel" },
2939     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2940         "deprecated, use -standard", "standard" },
2941     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2942
2943     /* muxer options */
2944     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2945         "set the maximum demux-decode delay", "seconds" },
2946     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2947         "set the initial demux-decode delay", "seconds" },
2948     { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
2949         "override the options from ffserver", "" },
2950
2951     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2952         "A comma-separated list of bitstream filters", "bitstream_filters" },
2953     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2954         "deprecated", "audio bitstream_filters" },
2955     { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2956         "deprecated", "video bitstream_filters" },
2957
2958     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
2959         "set the audio options to the indicated preset", "preset" },
2960     { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
2961         "set the video options to the indicated preset", "preset" },
2962     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2963         "set the subtitle options to the indicated preset", "preset" },
2964     { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,                { .func_arg = opt_preset },
2965         "set options from indicated preset file", "filename" },
2966     /* data codec support */
2967     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2968         "force data codec ('copy' to copy stream)", "codec" },
2969     { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
2970         "disable data" },
2971
2972     { NULL, },
2973 };