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