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

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