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->codecpar->codec_type, 0);
 474         st->codecpar->codec_id = codec->id;
 475         return codec;
 476     } else
 477         return avcodec_find_decoder(st->codecpar->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         AVCodecParameters *par = st->codecpar;
 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->codecpar->codec_tag = tag;
 520         }
 521
 522         ist->dec = choose_decoder(o, ic, st);
 523         ist->decoder_opts = filter_codec_opts(o->g->codec_opts, par->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_parameters_to_context(ist->dec_ctx, par);
 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 (par->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->codecpar->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->codecpar->extradata, st->codecpar->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->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
 899                                                      NULL, ost->st->codecpar->codec_type);
 900         ost->enc = avcodec_find_encoder(ost->st->codecpar->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->codecpar->codec_type, 1);
 905         ost->st->codecpar->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     double qscale = -1;
 916
 917     if (!st) {
 918         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
 919         exit_program(1);
 920     }
 921
 922     if (oc->nb_streams - 1 < o->nb_streamid_map)
 923         st->id = o->streamid_map[oc->nb_streams - 1];
 924
 925     GROW_ARRAY(output_streams, nb_output_streams);
 926     if (!(ost = av_mallocz(sizeof(*ost))))
 927         exit_program(1);
 928     output_streams[nb_output_streams - 1] = ost;
 929
 930     ost->file_index = nb_output_files - 1;
 931     ost->index      = idx;
 932     ost->st         = st;
 933     st->codecpar->codec_type = type;
 934     choose_encoder(o, oc, ost);
 935
 936     ost->enc_ctx = avcodec_alloc_context3(ost->enc);
 937     if (!ost->enc_ctx) {
 938         av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
 939         exit_program(1);
 940     }
 941     ost->enc_ctx->codec_type = type;
 942
 943     if (ost->enc) {
 944         AVIOContext *s = NULL;
 945         char *buf = NULL, *arg = NULL, *preset = NULL;
 946
 947         ost->encoder_opts  = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
 948
 949         MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
 950         if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
 951             do  {
 952                 buf = get_line(s);
 953                 if (!buf[0] || buf[0] == '#') {
 954                     av_free(buf);
 955                     continue;
 956                 }
 957                 if (!(arg = strchr(buf, '='))) {
 958                     av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
 959                     exit_program(1);
 960                 }
 961                 *arg++ = 0;
 962                 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
 963                 av_free(buf);
 964             } while (!s->eof_reached);
 965             avio_close(s);
 966         }
 967         if (ret) {
 968             av_log(NULL, AV_LOG_FATAL,
 969                    "Preset %s specified for stream %d:%d, but could not be opened.\n",
 970                    preset, ost->file_index, ost->index);
 971             exit_program(1);
 972         }
 973     } else {
 974         ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
 975     }
 976
 977     ost->max_frames = INT64_MAX;
 978     MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
 979
 980     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
 981     while (bsf) {
 982         const AVBitStreamFilter *filter;
 983
 984         if (next = strchr(bsf, ','))
 985             *next++ = 0;
 986
 987         filter = av_bsf_get_by_name(bsf);
 988         if (!bsf) {
 989             av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
 990             exit_program(1);
 991         }
 992
 993         ost->bitstream_filters = av_realloc_array(ost->bitstream_filters,
 994                                                   ost->nb_bitstream_filters + 1,
 995                                                   sizeof(*ost->bitstream_filters));
 996         if (!ost->bitstream_filters)
 997             exit_program(1);
 998
 999         ost->bitstream_filters[ost->nb_bitstream_filters++] = filter;
1000
1001         bsf = next;
1002     }
1003
1004     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1005     if (codec_tag) {
1006         uint32_t tag = strtol(codec_tag, &next, 0);
1007         if (*next)
1008             tag = AV_RL32(codec_tag);
1009         ost->enc_ctx->codec_tag = tag;
1010     }
1011
1012     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1013     if (qscale >= 0) {
1014         ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1015         ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1016     }
1017
1018     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1019         ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1020
1021     av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1022
1023     av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1024
1025     ost->pix_fmts[0] = ost->pix_fmts[1] = AV_PIX_FMT_NONE;
1026     ost->last_mux_dts = AV_NOPTS_VALUE;
1027
1028     return ost;
1029 }
1030
1031 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1032 {
1033     int i;
1034     const char *p = str;
1035     for (i = 0;; i++) {
1036         dest[i] = atoi(p);
1037         if (i == 63)
1038             break;
1039         p = strchr(p, ',');
1040         if (!p) {
1041             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1042             exit_program(1);
1043         }
1044         p++;
1045     }
1046 }
1047
1048 /* read file contents into a string */
1049 static uint8_t *read_file(const char *filename)
1050 {
1051     AVIOContext *pb      = NULL;
1052     AVIOContext *dyn_buf = NULL;
1053     int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1054     uint8_t buf[1024], *str;
1055
1056     if (ret < 0) {
1057         av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1058         return NULL;
1059     }
1060
1061     ret = avio_open_dyn_buf(&dyn_buf);
1062     if (ret < 0) {
1063         avio_closep(&pb);
1064         return NULL;
1065     }
1066     while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1067         avio_write(dyn_buf, buf, ret);
1068     avio_w8(dyn_buf, 0);
1069     avio_closep(&pb);
1070
1071     ret = avio_close_dyn_buf(dyn_buf, &str);
1072     if (ret < 0)
1073         return NULL;
1074     return str;
1075 }
1076
1077 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1078                              OutputStream *ost)
1079 {
1080     AVStream *st = ost->st;
1081     char *filter = NULL, *filter_script = NULL;
1082
1083     MATCH_PER_STREAM_OPT(filter_scripts, str, filter_script, oc, st);
1084     MATCH_PER_STREAM_OPT(filters, str, filter, oc, st);
1085
1086     if (filter_script && filter) {
1087         av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1088                "output stream #%d:%d.\n", nb_output_files, st->index);
1089         exit_program(1);
1090     }
1091
1092     if (filter_script)
1093         return read_file(filter_script);
1094     else if (filter)
1095         return av_strdup(filter);
1096
1097     return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1098                      "null" : "anull");
1099 }
1100
1101 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
1102 {
1103     AVStream *st;
1104     OutputStream *ost;
1105     AVCodecContext *video_enc;
1106     char *frame_aspect_ratio = NULL;
1107
1108     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
1109     st  = ost->st;
1110     video_enc = ost->enc_ctx;
1111
1112     MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1113     if (frame_aspect_ratio)
1114         ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
1115
1116     if (!ost->stream_copy) {
1117         const char *p = NULL;
1118         char *frame_rate = NULL, *frame_size = NULL;
1119         char *frame_pix_fmt = NULL;
1120         char *intra_matrix = NULL, *inter_matrix = NULL;
1121         int do_pass = 0;
1122         int i;
1123
1124         MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1125         if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1126             av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1127             exit_program(1);
1128         }
1129
1130         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1131         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1132             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1133             exit_program(1);
1134         }
1135
1136         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1137         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1138             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1139             exit_program(1);
1140         }
1141         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1142
1143         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1144         if (intra_matrix) {
1145             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1146                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1147                 exit_program(1);
1148             }
1149             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1150         }
1151         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1152         if (inter_matrix) {
1153             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1154                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1155                 exit_program(1);
1156             }
1157             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1158         }
1159
1160         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1161         for (i = 0; p; i++) {
1162             int start, end, q;
1163             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1164             if (e != 3) {
1165                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1166                 exit_program(1);
1167             }
1168             video_enc->rc_override =
1169                 av_realloc(video_enc->rc_override,
1170                            sizeof(RcOverride) * (i + 1));
1171             if (!video_enc->rc_override) {
1172                 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1173                 exit_program(1);
1174             }
1175             video_enc->rc_override[i].start_frame = start;
1176             video_enc->rc_override[i].end_frame   = end;
1177             if (q > 0) {
1178                 video_enc->rc_override[i].qscale         = q;
1179                 video_enc->rc_override[i].quality_factor = 1.0;
1180             }
1181             else {
1182                 video_enc->rc_override[i].qscale         = 0;
1183                 video_enc->rc_override[i].quality_factor = -q/100.0;
1184             }
1185             p = strchr(p, '/');
1186             if (p) p++;
1187         }
1188         video_enc->rc_override_count = i;
1189         video_enc->intra_dc_precision = intra_dc_precision - 8;
1190
1191         /* two pass mode */
1192         MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1193         if (do_pass) {
1194             if (do_pass == 1) {
1195                 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1196             } else {
1197                 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1198             }
1199         }
1200
1201         MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1202         if (ost->logfile_prefix &&
1203             !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1204             exit_program(1);
1205
1206         if (do_pass) {
1207             char logfilename[1024];
1208             FILE *f;
1209
1210             snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1211                      ost->logfile_prefix ? ost->logfile_prefix :
1212                                            DEFAULT_PASS_LOGFILENAME_PREFIX,
1213                      i);
1214             if (!strcmp(ost->enc->name, "libx264")) {
1215                 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1216             } else {
1217                 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1218                     f = fopen(logfilename, "wb");
1219                     if (!f) {
1220                         av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
1221                                logfilename, strerror(errno));
1222                         exit_program(1);
1223                     }
1224                     ost->logfile = f;
1225                 } else {
1226                     char  *logbuffer = read_file(logfilename);
1227
1228                     if (!logbuffer) {
1229                         av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1230                                logfilename);
1231                         exit_program(1);
1232                     }
1233                     video_enc->stats_in = logbuffer;
1234                 }
1235             }
1236         }
1237
1238         MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1239         if (ost->forced_keyframes)
1240             ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1241
1242         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1243
1244         ost->top_field_first = -1;
1245         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1246
1247
1248         ost->avfilter = get_ost_filters(o, oc, ost);
1249         if (!ost->avfilter)
1250             exit_program(1);
1251     } else {
1252         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1253     }
1254
1255     return ost;
1256 }
1257
1258 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
1259 {
1260     AVStream *st;
1261     OutputStream *ost;
1262     AVCodecContext *audio_enc;
1263
1264     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
1265     st  = ost->st;
1266
1267     audio_enc = ost->enc_ctx;
1268     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1269
1270     if (!ost->stream_copy) {
1271         char *sample_fmt = NULL;
1272
1273         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1274
1275         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1276         if (sample_fmt &&
1277             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1278             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1279             exit_program(1);
1280         }
1281
1282         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1283
1284         ost->avfilter = get_ost_filters(o, oc, ost);
1285         if (!ost->avfilter)
1286             exit_program(1);
1287     }
1288
1289     return ost;
1290 }
1291
1292 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
1293 {
1294     OutputStream *ost;
1295
1296     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
1297     if (!ost->stream_copy) {
1298         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1299         exit_program(1);
1300     }
1301
1302     return ost;
1303 }
1304
1305 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
1306 {
1307     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
1308     ost->stream_copy = 1;
1309     ost->finished    = 1;
1310     return ost;
1311 }
1312
1313 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
1314 {
1315     OutputStream *ost;
1316     AVCodecContext *subtitle_enc;
1317
1318     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
1319     subtitle_enc = ost->enc_ctx;
1320
1321     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1322
1323     return ost;
1324 }
1325
1326 /* arg format is "output-stream-index:streamid-value". */
1327 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1328 {
1329     OptionsContext *o = optctx;
1330     int idx;
1331     char *p;
1332     char idx_str[16];
1333
1334     av_strlcpy(idx_str, arg, sizeof(idx_str));
1335     p = strchr(idx_str, ':');
1336     if (!p) {
1337         av_log(NULL, AV_LOG_FATAL,
1338                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1339                arg, opt);
1340         exit_program(1);
1341     }
1342     *p++ = '\0';
1343     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
1344     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1345     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1346     return 0;
1347 }
1348
1349 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1350 {
1351     AVFormatContext *is = ifile->ctx;
1352     AVFormatContext *os = ofile->ctx;
1353     AVChapter **tmp;
1354     int i;
1355
1356     tmp = av_realloc(os->chapters, sizeof(*os->chapters) * (is->nb_chapters + os->nb_chapters));
1357     if (!tmp)
1358         return AVERROR(ENOMEM);
1359     os->chapters = tmp;
1360
1361     for (i = 0; i < is->nb_chapters; i++) {
1362         AVChapter *in_ch = is->chapters[i], *out_ch;
1363         int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1364         int64_t ts_off   = av_rescale_q(start_time - ifile->ts_offset,
1365                                        AV_TIME_BASE_Q, in_ch->time_base);
1366         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1367                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1368
1369
1370         if (in_ch->end < ts_off)
1371             continue;
1372         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1373             break;
1374
1375         out_ch = av_mallocz(sizeof(AVChapter));
1376         if (!out_ch)
1377             return AVERROR(ENOMEM);
1378
1379         out_ch->id        = in_ch->id;
1380         out_ch->time_base = in_ch->time_base;
1381         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1382         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1383
1384         if (copy_metadata)
1385             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1386
1387         os->chapters[os->nb_chapters++] = out_ch;
1388     }
1389     return 0;
1390 }
1391
1392 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1393                                AVFormatContext *oc)
1394 {
1395     OutputStream *ost;
1396
1397     switch (ofilter->type) {
1398     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1399     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1400     default:
1401         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1402                "currently.\n");
1403         exit_program(1);
1404     }
1405
1406     ost->source_index = -1;
1407     ost->filter       = ofilter;
1408
1409     ofilter->ost      = ost;
1410
1411     if (ost->stream_copy) {
1412         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1413                "which is fed from a complex filtergraph. Filtering and streamcopy "
1414                "cannot be used together.\n", ost->file_index, ost->index);
1415         exit_program(1);
1416     }
1417
1418     avfilter_inout_free(&ofilter->out_tmp);
1419 }
1420
1421 static int init_complex_filters(void)
1422 {
1423     int i, ret = 0;
1424
1425     for (i = 0; i < nb_filtergraphs; i++) {
1426         ret = init_complex_filtergraph(filtergraphs[i]);
1427         if (ret < 0)
1428             return ret;
1429     }
1430     return 0;
1431 }
1432
1433 static int configure_complex_filters(void)
1434 {
1435     int i, ret = 0;
1436
1437     for (i = 0; i < nb_filtergraphs; i++)
1438         if (!filtergraphs[i]->graph &&
1439             (ret = configure_filtergraph(filtergraphs[i])) < 0)
1440             return ret;
1441     return 0;
1442 }
1443
1444 static int open_output_file(OptionsContext *o, const char *filename)
1445 {
1446     AVFormatContext *oc;
1447     int i, j, err;
1448     AVOutputFormat *file_oformat;
1449     OutputFile *of;
1450     OutputStream *ost;
1451     InputStream  *ist;
1452     AVDictionary *unused_opts = NULL;
1453     AVDictionaryEntry *e = NULL;
1454
1455     GROW_ARRAY(output_files, nb_output_files);
1456     of = av_mallocz(sizeof(*of));
1457     if (!of)
1458         exit_program(1);
1459     output_files[nb_output_files - 1] = of;
1460
1461     of->ost_index      = nb_output_streams;
1462     of->recording_time = o->recording_time;
1463     of->start_time     = o->start_time;
1464     of->limit_filesize = o->limit_filesize;
1465     of->shortest       = o->shortest;
1466     av_dict_copy(&of->opts, o->g->format_opts, 0);
1467
1468     if (!strcmp(filename, "-"))
1469         filename = "pipe:";
1470
1471     oc = avformat_alloc_context();
1472     if (!oc) {
1473         print_error(filename, AVERROR(ENOMEM));
1474         exit_program(1);
1475     }
1476     of->ctx = oc;
1477     if (o->recording_time != INT64_MAX)
1478         oc->duration = o->recording_time;
1479
1480     if (o->format) {
1481         file_oformat = av_guess_format(o->format, NULL, NULL);
1482         if (!file_oformat) {
1483             av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
1484             exit_program(1);
1485         }
1486     } else {
1487         file_oformat = av_guess_format(NULL, filename, NULL);
1488         if (!file_oformat) {
1489             av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
1490                    filename);
1491             exit_program(1);
1492         }
1493     }
1494
1495     oc->oformat = file_oformat;
1496     oc->interrupt_callback = int_cb;
1497     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
1498
1499     /* create streams for all unlabeled output pads */
1500     for (i = 0; i < nb_filtergraphs; i++) {
1501         FilterGraph *fg = filtergraphs[i];
1502         for (j = 0; j < fg->nb_outputs; j++) {
1503             OutputFilter *ofilter = fg->outputs[j];
1504
1505             if (!ofilter->out_tmp || ofilter->out_tmp->name)
1506                 continue;
1507
1508             switch (ofilter->type) {
1509             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
1510             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
1511             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1512             }
1513             init_output_filter(ofilter, o, oc);
1514         }
1515     }
1516
1517     if (!o->nb_stream_maps) {
1518         /* pick the "best" stream of each type */
1519 #define NEW_STREAM(type, index)\
1520         if (index >= 0) {\
1521             ost = new_ ## type ## _stream(o, oc);\
1522             ost->source_index = index;\
1523             ost->sync_ist     = input_streams[index];\
1524             input_streams[index]->discard = 0;\
1525             input_streams[index]->st->discard = AVDISCARD_NONE;\
1526         }
1527
1528         /* video: highest resolution */
1529         if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1530             int area = 0, idx = -1;
1531             for (i = 0; i < nb_input_streams; i++) {
1532                 ist = input_streams[i];
1533                 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
1534                     ist->st->codecpar->width * ist->st->codecpar->height > area) {
1535                     area = ist->st->codecpar->width * ist->st->codecpar->height;
1536                     idx = i;
1537                 }
1538             }
1539             NEW_STREAM(video, idx);
1540         }
1541
1542         /* audio: most channels */
1543         if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1544             int channels = 0, idx = -1;
1545             for (i = 0; i < nb_input_streams; i++) {
1546                 ist = input_streams[i];
1547                 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
1548                     ist->st->codecpar->channels > channels) {
1549                     channels = ist->st->codecpar->channels;
1550                     idx = i;
1551                 }
1552             }
1553             NEW_STREAM(audio, idx);
1554         }
1555
1556         /* subtitles: pick first */
1557         if (!o->subtitle_disable && oc->oformat->subtitle_codec != AV_CODEC_ID_NONE) {
1558             for (i = 0; i < nb_input_streams; i++)
1559                 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1560                     NEW_STREAM(subtitle, i);
1561                     break;
1562                 }
1563         }
1564         /* do something with data? */
1565     } else {
1566         for (i = 0; i < o->nb_stream_maps; i++) {
1567             StreamMap *map = &o->stream_maps[i];
1568
1569             if (map->disabled)
1570                 continue;
1571
1572             if (map->linklabel) {
1573                 FilterGraph *fg;
1574                 OutputFilter *ofilter = NULL;
1575                 int j, k;
1576
1577                 for (j = 0; j < nb_filtergraphs; j++) {
1578                     fg = filtergraphs[j];
1579                     for (k = 0; k < fg->nb_outputs; k++) {
1580                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
1581                         if (out && !strcmp(out->name, map->linklabel)) {
1582                             ofilter = fg->outputs[k];
1583                             goto loop_end;
1584                         }
1585                     }
1586                 }
1587 loop_end:
1588                 if (!ofilter) {
1589                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1590                            "in any defined filter graph.\n", map->linklabel);
1591                     exit_program(1);
1592                 }
1593                 init_output_filter(ofilter, o, oc);
1594             } else {
1595                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1596                 switch (ist->st->codecpar->codec_type) {
1597                 case AVMEDIA_TYPE_VIDEO:    ost = new_video_stream(o, oc);    break;
1598                 case AVMEDIA_TYPE_AUDIO:    ost = new_audio_stream(o, oc);    break;
1599                 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
1600                 case AVMEDIA_TYPE_DATA:     ost = new_data_stream(o, oc);     break;
1601                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
1602                 default:
1603                     av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1604                            map->file_index, map->stream_index);
1605                     exit_program(1);
1606                 }
1607
1608                 ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
1609                 ost->sync_ist     = input_streams[input_files[map->sync_file_index]->ist_index +
1610                                                map->sync_stream_index];
1611                 ist->discard = 0;
1612                 ist->st->discard = AVDISCARD_NONE;
1613             }
1614         }
1615     }
1616
1617     /* handle attached files */
1618     for (i = 0; i < o->nb_attachments; i++) {
1619         AVIOContext *pb;
1620         uint8_t *attachment;
1621         const char *p;
1622         int64_t len;
1623
1624         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1625             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1626                    o->attachments[i]);
1627             exit_program(1);
1628         }
1629         if ((len = avio_size(pb)) <= 0) {
1630             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1631                    o->attachments[i]);
1632             exit_program(1);
1633         }
1634         if (!(attachment = av_malloc(len))) {
1635             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1636                    o->attachments[i]);
1637             exit_program(1);
1638         }
1639         avio_read(pb, attachment, len);
1640
1641         ost = new_attachment_stream(o, oc);
1642         ost->stream_copy               = 0;
1643         ost->source_index              = -1;
1644         ost->attachment_filename       = o->attachments[i];
1645         ost->st->codecpar->extradata      = attachment;
1646         ost->st->codecpar->extradata_size = len;
1647
1648         p = strrchr(o->attachments[i], '/');
1649         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1650         avio_close(pb);
1651     }
1652
1653     if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
1654         av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
1655         av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
1656         exit_program(1);
1657     }
1658
1659     /* check if all codec options have been used */
1660     unused_opts = strip_specifiers(o->g->codec_opts);
1661     for (i = of->ost_index; i < nb_output_streams; i++) {
1662         e = NULL;
1663         while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
1664                                 AV_DICT_IGNORE_SUFFIX)))
1665             av_dict_set(&unused_opts, e->key, NULL, 0);
1666     }
1667
1668     e = NULL;
1669     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1670         const AVClass *class = avcodec_get_class();
1671         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1672                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1673         if (!option)
1674             continue;
1675         if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1676             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1677                    "output file #%d (%s) is not an encoding option.\n", e->key,
1678                    option->help ? option->help : "", nb_output_files - 1,
1679                    filename);
1680             exit_program(1);
1681         }
1682
1683         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1684                "output file #%d (%s) has not been used for any stream. The most "
1685                "likely reason is either wrong type (e.g. a video option with "
1686                "no video streams) or that it is a private option of some encoder "
1687                "which was not actually used for any stream.\n", e->key,
1688                option->help ? option->help : "", nb_output_files - 1, filename);
1689     }
1690     av_dict_free(&unused_opts);
1691
1692     /* set the encoding/decoding_needed flags */
1693     for (i = of->ost_index; i < nb_output_streams; i++) {
1694         OutputStream *ost = output_streams[i];
1695
1696         ost->encoding_needed = !ost->stream_copy;
1697         if (ost->encoding_needed && ost->source_index >= 0) {
1698             InputStream *ist = input_streams[ost->source_index];
1699             ist->decoding_needed = 1;
1700         }
1701     }
1702
1703     /* check filename in case of an image number is expected */
1704     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1705         if (!av_filename_number_test(oc->filename)) {
1706             print_error(oc->filename, AVERROR(EINVAL));
1707             exit_program(1);
1708         }
1709     }
1710
1711     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1712         /* test if it already exists to avoid losing precious files */
1713         assert_file_overwrite(filename);
1714
1715         /* open the file */
1716         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1717                               &oc->interrupt_callback,
1718                               &of->opts)) < 0) {
1719             print_error(filename, err);
1720             exit_program(1);
1721         }
1722     }
1723
1724     if (o->mux_preload) {
1725         uint8_t buf[64];
1726         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1727         av_dict_set(&of->opts, "preload", buf, 0);
1728     }
1729     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1730     oc->flags |= AVFMT_FLAG_NONBLOCK;
1731
1732     /* copy metadata */
1733     for (i = 0; i < o->nb_metadata_map; i++) {
1734         char *p;
1735         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1736
1737         if (in_file_index >= nb_input_files) {
1738             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1739             exit_program(1);
1740         }
1741         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1742                       in_file_index >= 0 ?
1743                       input_files[in_file_index]->ctx : NULL, o);
1744     }
1745
1746     /* copy chapters */
1747     if (o->chapters_input_file >= nb_input_files) {
1748         if (o->chapters_input_file == INT_MAX) {
1749             /* copy chapters from the first input file that has them*/
1750             o->chapters_input_file = -1;
1751             for (i = 0; i < nb_input_files; i++)
1752                 if (input_files[i]->ctx->nb_chapters) {
1753                     o->chapters_input_file = i;
1754                     break;
1755                 }
1756         } else {
1757             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1758                    o->chapters_input_file);
1759             exit_program(1);
1760         }
1761     }
1762     if (o->chapters_input_file >= 0)
1763         copy_chapters(input_files[o->chapters_input_file], of,
1764                       !o->metadata_chapters_manual);
1765
1766     /* copy global metadata by default */
1767     if (!o->metadata_global_manual && nb_input_files)
1768         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1769                      AV_DICT_DONT_OVERWRITE);
1770     if (!o->metadata_streams_manual)
1771         for (i = of->ost_index; i < nb_output_streams; i++) {
1772             InputStream *ist;
1773             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
1774                 continue;
1775             ist = input_streams[output_streams[i]->source_index];
1776             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1777         }
1778
1779     /* process manually set metadata */
1780     for (i = 0; i < o->nb_metadata; i++) {
1781         AVDictionary **m;
1782         char type, *val;
1783         const char *stream_spec;
1784         int index = 0, j, ret;
1785
1786         val = strchr(o->metadata[i].u.str, '=');
1787         if (!val) {
1788             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1789                    o->metadata[i].u.str);
1790             exit_program(1);
1791         }
1792         *val++ = 0;
1793
1794         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1795         if (type == 's') {
1796             for (j = 0; j < oc->nb_streams; j++) {
1797                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1798                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1799                 } else if (ret < 0)
1800                     exit_program(1);
1801             }
1802         }
1803         else {
1804             switch (type) {
1805             case 'g':
1806                 m = &oc->metadata;
1807                 break;
1808             case 'c':
1809                 if (index < 0 || index >= oc->nb_chapters) {
1810                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1811                     exit_program(1);
1812                 }
1813                 m = &oc->chapters[index]->metadata;
1814                 break;
1815             default:
1816                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1817                 exit_program(1);
1818             }
1819             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1820         }
1821     }
1822
1823     return 0;
1824 }
1825
1826 static int opt_target(void *optctx, const char *opt, const char *arg)
1827 {
1828     OptionsContext *o = optctx;
1829     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1830     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1831
1832     if (!strncmp(arg, "pal-", 4)) {
1833         norm = PAL;
1834         arg += 4;
1835     } else if (!strncmp(arg, "ntsc-", 5)) {
1836         norm = NTSC;
1837         arg += 5;
1838     } else if (!strncmp(arg, "film-", 5)) {
1839         norm = FILM;
1840         arg += 5;
1841     } else {
1842         /* Try to determine PAL/NTSC by peeking in the input files */
1843         if (nb_input_files) {
1844             int i, j, fr;
1845             for (j = 0; j < nb_input_files; j++) {
1846                 for (i = 0; i < input_files[j]->nb_streams; i++) {
1847                     AVStream *st = input_files[j]->ctx->streams[i];
1848                     if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
1849                         continue;
1850                     fr = st->time_base.den * 1000 / st->time_base.num;
1851                     if (fr == 25000) {
1852                         norm = PAL;
1853                         break;
1854                     } else if ((fr == 29970) || (fr == 23976)) {
1855                         norm = NTSC;
1856                         break;
1857                     }
1858                 }
1859                 if (norm != UNKNOWN)
1860                     break;
1861             }
1862         }
1863         if (norm != UNKNOWN)
1864             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1865     }
1866
1867     if (norm == UNKNOWN) {
1868         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1869         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1870         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1871         exit_program(1);
1872     }
1873
1874     if (!strcmp(arg, "vcd")) {
1875         opt_video_codec(o, "c:v", "mpeg1video");
1876         opt_audio_codec(o, "c:a", "mp2");
1877         parse_option(o, "f", "vcd", options);
1878
1879         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1880         parse_option(o, "r", frame_rates[norm], options);
1881         opt_default(NULL, "g", norm == PAL ? "15" : "18");
1882
1883         opt_default(NULL, "b", "1150000");
1884         opt_default(NULL, "maxrate", "1150000");
1885         opt_default(NULL, "minrate", "1150000");
1886         opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1887
1888         opt_default(NULL, "b:a", "224000");
1889         parse_option(o, "ar", "44100", options);
1890         parse_option(o, "ac", "2", options);
1891
1892         opt_default(NULL, "packetsize", "2324");
1893         opt_default(NULL, "muxrate", "3528"); // 2352 * 75 / 50;
1894
1895         /* We have to offset the PTS, so that it is consistent with the SCR.
1896            SCR starts at 36000, but the first two packs contain only padding
1897            and the first pack from the other stream, respectively, may also have
1898            been written before.
1899            So the real data starts at SCR 36000+3*1200. */
1900         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1901     } else if (!strcmp(arg, "svcd")) {
1902
1903         opt_video_codec(o, "c:v", "mpeg2video");
1904         opt_audio_codec(o, "c:a", "mp2");
1905         parse_option(o, "f", "svcd", options);
1906
1907         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1908         parse_option(o, "r", frame_rates[norm], options);
1909         opt_default(NULL, "g", norm == PAL ? "15" : "18");
1910
1911         opt_default(NULL, "b", "2040000");
1912         opt_default(NULL, "maxrate", "2516000");
1913         opt_default(NULL, "minrate", "0"); // 1145000;
1914         opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1915         opt_default(NULL, "scan_offset", "1");
1916
1917
1918         opt_default(NULL, "b:a", "224000");
1919         parse_option(o, "ar", "44100", options);
1920
1921         opt_default(NULL, "packetsize", "2324");
1922
1923     } else if (!strcmp(arg, "dvd")) {
1924
1925         opt_video_codec(o, "c:v", "mpeg2video");
1926         opt_audio_codec(o, "c:a", "ac3");
1927         parse_option(o, "f", "dvd", options);
1928
1929         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1930         parse_option(o, "r", frame_rates[norm], options);
1931         opt_default(NULL, "g", norm == PAL ? "15" : "18");
1932
1933         opt_default(NULL, "b", "6000000");
1934         opt_default(NULL, "maxrate", "9000000");
1935         opt_default(NULL, "minrate", "0"); // 1500000;
1936         opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1937
1938         opt_default(NULL, "packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1939         opt_default(NULL, "muxrate", "25200"); // from mplex project: data_rate = 1260000. mux_rate = data_rate / 50
1940
1941         opt_default(NULL, "b:a", "448000");
1942         parse_option(o, "ar", "48000", options);
1943
1944     } else if (!strncmp(arg, "dv", 2)) {
1945
1946         parse_option(o, "f", "dv", options);
1947
1948         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1949         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1950                           norm == PAL ? "yuv420p" : "yuv411p", options);
1951         parse_option(o, "r", frame_rates[norm], options);
1952
1953         parse_option(o, "ar", "48000", options);
1954         parse_option(o, "ac", "2", options);
1955
1956     } else {
1957         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1958         return AVERROR(EINVAL);
1959     }
1960
1961     av_dict_copy(&o->g->codec_opts,  codec_opts, 0);
1962     av_dict_copy(&o->g->format_opts, format_opts, 0);
1963
1964     return 0;
1965 }
1966
1967 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1968 {
1969     av_free (vstats_filename);
1970     vstats_filename = av_strdup (arg);
1971     return 0;
1972 }
1973
1974 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1975 {
1976     char filename[40];
1977     time_t today2 = time(NULL);
1978     struct tm *today = localtime(&today2);
1979
1980     if (!today) { // maybe tomorrow
1981         av_log(NULL, AV_LOG_FATAL, "Unable to get current time.\n");
1982         exit_program(1);
1983     }
1984
1985     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1986              today->tm_sec);
1987     return opt_vstats_file(NULL, opt, filename);
1988 }
1989
1990 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1991 {
1992     OptionsContext *o = optctx;
1993     return parse_option(o, "frames:v", arg, options);
1994 }
1995
1996 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1997 {
1998     OptionsContext *o = optctx;
1999     return parse_option(o, "frames:a", arg, options);
2000 }
2001
2002 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2003 {
2004     OptionsContext *o = optctx;
2005     return parse_option(o, "frames:d", arg, options);
2006 }
2007
2008 static int opt_video_tag(void *optctx, const char *opt, const char *arg)
2009 {
2010     OptionsContext *o = optctx;
2011     return parse_option(o, "tag:v", arg, options);
2012 }
2013
2014 static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
2015 {
2016     OptionsContext *o = optctx;
2017     return parse_option(o, "tag:a", arg, options);
2018 }
2019
2020 static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
2021 {
2022     OptionsContext *o = optctx;
2023     return parse_option(o, "tag:s", arg, options);
2024 }
2025
2026 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2027 {
2028     OptionsContext *o = optctx;
2029     return parse_option(o, "filter:v", arg, options);
2030 }
2031
2032 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2033 {
2034     OptionsContext *o = optctx;
2035     return parse_option(o, "filter:a", arg, options);
2036 }
2037
2038 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2039 {
2040     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
2041     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
2042     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2043
2044     if (video_sync_method == VSYNC_AUTO)
2045         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2046     return 0;
2047 }
2048
2049 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2050 {
2051     OptionsContext *o = optctx;
2052     char layout_str[32];
2053     char *stream_str;
2054     char *ac_str;
2055     int ret, channels, ac_str_size;
2056     uint64_t layout;
2057
2058     layout = av_get_channel_layout(arg);
2059     if (!layout) {
2060         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2061         return AVERROR(EINVAL);
2062     }
2063     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2064     ret = opt_default(NULL, opt, layout_str);
2065     if (ret < 0)
2066         return ret;
2067
2068     /* set 'ac' option based on channel layout */
2069     channels = av_get_channel_layout_nb_channels(layout);
2070     snprintf(layout_str, sizeof(layout_str), "%d", channels);
2071     stream_str = strchr(opt, ':');
2072     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2073     ac_str = av_mallocz(ac_str_size);
2074     if (!ac_str)
2075         return AVERROR(ENOMEM);
2076     av_strlcpy(ac_str, "ac", 3);
2077     if (stream_str)
2078         av_strlcat(ac_str, stream_str, ac_str_size);
2079     ret = parse_option(o, ac_str, layout_str, options);
2080     av_free(ac_str);
2081
2082     return ret;
2083 }
2084
2085 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2086 {
2087     OptionsContext *o = optctx;
2088     return parse_option(o, "q:a", arg, options);
2089 }
2090
2091 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2092 {
2093     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2094     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2095         return AVERROR(ENOMEM);
2096     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2097     filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2098     if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2099         return AVERROR(ENOMEM);
2100     return 0;
2101 }
2102
2103 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2104 {
2105     uint8_t *graph_desc = read_file(arg);
2106     if (!graph_desc)
2107         return AVERROR(EINVAL);
2108
2109     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2110     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2111         return AVERROR(ENOMEM);
2112     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2113     filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2114     return 0;
2115 }
2116
2117 void show_help_default(const char *opt, const char *arg)
2118 {
2119     /* per-file options have at least one of those set */
2120     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2121     int show_advanced = 0, show_avoptions = 0;
2122
2123     if (opt && *opt) {
2124         if (!strcmp(opt, "long"))
2125             show_advanced = 1;
2126         else if (!strcmp(opt, "full"))
2127             show_advanced = show_avoptions = 1;
2128         else
2129             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2130     }
2131
2132     show_usage();
2133
2134     printf("Getting help:\n"
2135            "    -h      -- print basic options\n"
2136            "    -h long -- print more options\n"
2137            "    -h full -- print all options (including all format and codec specific options, very long)\n"
2138            "    -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
2139            "    See man %s for detailed description of the options.\n"
2140            "\n", program_name);
2141
2142     show_help_options(options, "Print help / information / capabilities:",
2143                       OPT_EXIT, 0, 0);
2144
2145     show_help_options(options, "Global options (affect whole program "
2146                       "instead of just one file:",
2147                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2148     if (show_advanced)
2149         show_help_options(options, "Advanced global options:", OPT_EXPERT,
2150                           per_file | OPT_EXIT, 0);
2151
2152     show_help_options(options, "Per-file main options:", 0,
2153                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2154                       OPT_EXIT, per_file);
2155     if (show_advanced)
2156         show_help_options(options, "Advanced per-file options:",
2157                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2158
2159     show_help_options(options, "Video options:",
2160                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2161     if (show_advanced)
2162         show_help_options(options, "Advanced Video options:",
2163                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2164
2165     show_help_options(options, "Audio options:",
2166                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2167     if (show_advanced)
2168         show_help_options(options, "Advanced Audio options:",
2169                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2170     show_help_options(options, "Subtitle options:",
2171                       OPT_SUBTITLE, 0, 0);
2172     printf("\n");
2173
2174     if (show_avoptions) {
2175         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2176         show_help_children(avcodec_get_class(), flags);
2177         show_help_children(avformat_get_class(), flags);
2178         show_help_children(sws_get_class(), flags);
2179         show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM);
2180     }
2181 }
2182
2183 void show_usage(void)
2184 {
2185     printf("Hyper fast Audio and Video encoder\n");
2186     printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2187     printf("\n");
2188 }
2189
2190 enum OptGroup {
2191     GROUP_OUTFILE,
2192     GROUP_INFILE,
2193 };
2194
2195 static const OptionGroupDef groups[] = {
2196     [GROUP_OUTFILE] = { "output file",  NULL, OPT_OUTPUT },
2197     [GROUP_INFILE]  = { "input file",   "i",  OPT_INPUT },
2198 };
2199
2200 static int open_files(OptionGroupList *l, const char *inout,
2201                       int (*open_file)(OptionsContext*, const char*))
2202 {
2203     int i, ret;
2204
2205     for (i = 0; i < l->nb_groups; i++) {
2206         OptionGroup *g = &l->groups[i];
2207         OptionsContext o;
2208
2209         init_options(&o);
2210         o.g = g;
2211
2212         ret = parse_optgroup(&o, g);
2213         if (ret < 0) {
2214             av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2215                    "%s.\n", inout, g->arg);
2216             return ret;
2217         }
2218
2219         av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2220         ret = open_file(&o, g->arg);
2221         uninit_options(&o);
2222         if (ret < 0) {
2223             av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2224                    inout, g->arg);
2225             return ret;
2226         }
2227         av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2228     }
2229
2230     return 0;
2231 }
2232
2233 int avconv_parse_options(int argc, char **argv)
2234 {
2235     OptionParseContext octx;
2236     uint8_t error[128];
2237     int ret;
2238
2239     memset(&octx, 0, sizeof(octx));
2240
2241     /* split the commandline into an internal representation */
2242     ret = split_commandline(&octx, argc, argv, options, groups,
2243                             FF_ARRAY_ELEMS(groups));
2244     if (ret < 0) {
2245         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2246         goto fail;
2247     }
2248
2249     /* apply global options */
2250     ret = parse_optgroup(NULL, &octx.global_opts);
2251     if (ret < 0) {
2252         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2253         goto fail;
2254     }
2255
2256     /* open input files */
2257     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2258     if (ret < 0) {
2259         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2260         goto fail;
2261     }
2262
2263     /* create the complex filtergraphs */
2264     ret = init_complex_filters();
2265     if (ret < 0) {
2266         av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
2267         goto fail;
2268     }
2269
2270     /* open output files */
2271     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2272     if (ret < 0) {
2273         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2274         goto fail;
2275     }
2276
2277     /* configure the complex filtergraphs */
2278     ret = configure_complex_filters();
2279     if (ret < 0) {
2280         av_log(NULL, AV_LOG_FATAL, "Error configuring complex filters.\n");
2281         goto fail;
2282     }
2283
2284 fail:
2285     uninit_parse_context(&octx);
2286     if (ret < 0) {
2287         av_strerror(ret, error, sizeof(error));
2288         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2289     }
2290     return ret;
2291 }
2292
2293 #define OFFSET(x) offsetof(OptionsContext, x)
2294 const OptionDef options[] = {
2295     /* main options */
2296 #include "cmdutils_common_opts.h"
2297     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET |
2298                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(format) },
2299         "force format", "fmt" },
2300     { "y",              OPT_BOOL,                                    {              &file_overwrite },
2301         "overwrite output files" },
2302     { "n",              OPT_BOOL,                                    {              &file_skip },
2303         "never overwrite output files" },
2304     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC |
2305                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2306         "codec name", "codec" },
2307     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC |
2308                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2309         "codec name", "codec" },
2310     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC |
2311                         OPT_OUTPUT,                                  { .off       = OFFSET(presets) },
2312         "preset name", "preset" },
2313     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2314                         OPT_OUTPUT,                                  { .func_arg = opt_map },
2315         "set input stream mapping",
2316         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2317     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC |
2318                         OPT_OUTPUT,                                  { .off       = OFFSET(metadata_map) },
2319         "set metadata information of outfile from infile",
2320         "outfile[,metadata]:infile[,metadata]" },
2321     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2322                         OPT_OUTPUT,                                  { .off = OFFSET(chapters_input_file) },
2323         "set chapters mapping", "input_file_index" },
2324     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET |
2325                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(recording_time) },
2326         "record or transcode \"duration\" seconds of audio/video",
2327         "duration" },
2328     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2329         "set the limit file size in bytes", "limit_size" },
2330     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET |
2331                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time) },
2332         "set the start time offset", "time_off" },
2333     { "accurate_seek",  OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2334                         OPT_INPUT,                                   { .off = OFFSET(accurate_seek) },
2335         "enable/disable accurate seeking with -ss" },
2336     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET |
2337                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(input_ts_offset) },
2338         "set the input ts offset", "time_off" },
2339     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2340                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(ts_scale) },
2341         "set the input ts scale", "scale" },
2342     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2343         "add metadata", "string=string" },
2344     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2345                         OPT_OUTPUT,                                  { .func_arg = opt_data_frames },
2346         "set the number of data frames to record", "number" },
2347     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
2348         "add timings for benchmarking" },
2349     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
2350         "set max runtime in seconds", "limit" },
2351     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
2352         "dump each input packet" },
2353     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
2354         "when dumping packets, also dump the payload" },
2355     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2356                         OPT_INPUT,                                   { .off = OFFSET(rate_emu) },
2357         "read input at native frame rate", "" },
2358     { "target",         HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_target },
2359         "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2360         " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2361     { "vsync",          HAS_ARG | OPT_EXPERT,                        { opt_vsync },
2362         "video sync method", "" },
2363     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
2364         "audio sync method", "" },
2365     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
2366         "audio drift threshold", "threshold" },
2367     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
2368         "copy timestamps" },
2369     { "copytb",         OPT_BOOL | OPT_EXPERT,                       { &copy_tb },
2370         "copy input stream time base when stream copying" },
2371     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2372                         OPT_OUTPUT,                                  { .off = OFFSET(shortest) },
2373         "finish encoding within shortest input" },
2374     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
2375         "timestamp discontinuity delta threshold", "threshold" },
2376     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
2377         "exit on error", "error" },
2378     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2379                         OPT_OUTPUT,                                  { .off = OFFSET(copy_initial_nonkeyframes) },
2380         "copy initial non-keyframes" },
2381     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2382         "set the number of frames to record", "number" },
2383     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC |
2384                         OPT_EXPERT | OPT_OUTPUT | OPT_INPUT,         { .off = OFFSET(codec_tags) },
2385         "force codec tag/fourcc", "fourcc/tag" },
2386     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2387                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
2388         "use fixed quality scale (VBR)", "q" },
2389     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2390                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
2391         "use fixed quality scale (VBR)", "q" },
2392     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2393         "set stream filterchain", "filter_list" },
2394     { "filter_script",  HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2395         "read stream filtergraph description from a file", "filename" },
2396     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
2397         "create a complex filtergraph", "graph_description" },
2398     { "filter_complex_script", HAS_ARG | OPT_EXPERT,                 { .func_arg = opt_filter_complex_script },
2399         "read complex filtergraph description from a file", "filename" },
2400     { "stats",          OPT_BOOL,                                    { &print_stats },
2401         "print progress report during encoding", },
2402     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2403                         OPT_OUTPUT,                                  { .func_arg = opt_attach },
2404         "add an attachment to the output file", "filename" },
2405     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2406                          OPT_EXPERT | OPT_INPUT,                     { .off = OFFSET(dump_attachment) },
2407         "extract an attachment into a file", "filename" },
2408     { "loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
2409                         OPT_OFFSET,                                  { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
2410
2411     /* video options */
2412     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_frames },
2413         "set the number of video frames to record", "number" },
2414     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2415                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_rates) },
2416         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2417     { "s",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2418                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_sizes) },
2419         "set frame size (WxH or abbreviation)", "size" },
2420     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2421                       OPT_OUTPUT,                                                { .off = OFFSET(frame_aspect_ratios) },
2422         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2423     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2424                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_pix_fmts) },
2425         "set pixel format", "format" },
2426     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET | OPT_OUTPUT,           { .off = OFFSET(video_disable) },
2427         "disable video" },
2428     { "vdt",          OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &video_discard },
2429         "discard threshold", "n" },
2430     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2431                       OPT_OUTPUT,                                                { .off = OFFSET(rc_overrides) },
2432         "rate control override for specific intervals", "override" },
2433     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_INPUT |
2434                       OPT_OUTPUT,                                                { .func_arg = opt_video_codec },
2435         "force video codec ('copy' to copy stream)", "codec" },
2436     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT,     { .off = OFFSET(pass) },
2437         "select the pass number (1 or 2)", "n" },
2438     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2439                       OPT_OUTPUT,                                                { .off = OFFSET(passlogfiles) },
2440         "select two pass log file name prefix", "prefix" },
2441     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { &opt_vstats },
2442         "dump video coding statistics to file" },
2443     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { opt_vstats_file },
2444         "dump video coding statistics to file", "file" },
2445     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_filters },
2446         "video filters", "filter list" },
2447     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2448                       OPT_OUTPUT,                                                { .off = OFFSET(intra_matrices) },
2449         "specify intra matrix coeffs", "matrix" },
2450     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2451                       OPT_OUTPUT,                                                { .off = OFFSET(inter_matrices) },
2452         "specify inter matrix coeffs", "matrix" },
2453     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC |
2454                       OPT_OUTPUT,                                                { .off = OFFSET(top_field_first) },
2455         "top=1/bottom=0/auto=-1 field first", "" },
2456     { "dc",           OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &intra_dc_precision },
2457         "intra_dc_precision", "precision" },
2458     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE |
2459                       OPT_OUTPUT,                                                { .func_arg = opt_video_tag },
2460         "force video tag/fourcc", "fourcc/tag" },
2461     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
2462         "show QP histogram" },
2463     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC |
2464                       OPT_OUTPUT,                                                { .off = OFFSET(force_fps) },
2465         "force the selected framerate, disable the best supported framerate selection" },
2466     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2467                       OPT_OUTPUT,                                                { .func_arg = opt_streamid },
2468         "set the value of an outfile streamid", "streamIndex:value" },
2469     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2470                           OPT_SPEC | OPT_OUTPUT,                                 { .off = OFFSET(forced_key_frames) },
2471         "force key frames at specified timestamps", "timestamps" },
2472     { "hwaccel",          OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2473                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccels) },
2474         "use HW accelerated decoding", "hwaccel name" },
2475     { "hwaccel_device",   OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2476                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_devices) },
2477         "select a device for HW acceleration", "devicename" },
2478     { "hwaccels",         OPT_EXIT,                                              { .func_arg = show_hwaccels },
2479         "show available HW acceleration methods" },
2480     { "autorotate",       HAS_ARG | OPT_BOOL | OPT_SPEC |
2481                           OPT_EXPERT | OPT_INPUT,                                { .off = OFFSET(autorotate) },
2482         "automatically insert correct rotate filters" },
2483
2484     /* audio options */
2485     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_frames },
2486         "set the number of audio frames to record", "number" },
2487     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_qscale },
2488         "set audio quality (codec-specific)", "quality", },
2489     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
2490                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_sample_rate) },
2491         "set audio sampling rate (in Hz)", "rate" },
2492     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
2493                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_channels) },
2494         "set number of audio channels", "channels" },
2495     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT,            { .off = OFFSET(audio_disable) },
2496         "disable audio" },
2497     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE |
2498                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_audio_codec },
2499         "force audio codec ('copy' to copy stream)", "codec" },
2500     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
2501                         OPT_OUTPUT,                                                { .func_arg = opt_audio_tag },
2502         "force audio tag/fourcc", "fourcc/tag" },
2503     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
2504         "change audio volume (256=normal)" , "volume" },
2505     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC |
2506                         OPT_STRING | OPT_INPUT | OPT_OUTPUT,                       { .off = OFFSET(sample_fmts) },
2507         "set sample format", "format" },
2508     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
2509                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_channel_layout },
2510         "set channel layout", "layout" },
2511     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_filters },
2512         "audio filters", "filter list" },
2513
2514     /* subtitle options */
2515     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2516         "disable subtitle" },
2517     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2518         "force subtitle codec ('copy' to copy stream)", "codec" },
2519     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_subtitle_tag }
2520         , "force subtitle tag/fourcc", "fourcc/tag" },
2521
2522     /* grab options */
2523     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2524
2525     /* muxer options */
2526     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2527         "set the maximum demux-decode delay", "seconds" },
2528     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2529         "set the initial demux-decode delay", "seconds" },
2530
2531     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2532         "A comma-separated list of bitstream filters", "bitstream_filters" },
2533
2534     /* data codec support */
2535     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2536         "force data codec ('copy' to copy stream)", "codec" },
2537
2538     { NULL, },
2539 };