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

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