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