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