git.sesse.net Git - ffmpeg/blob - avconv_opt.c

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