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