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