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