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

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