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