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