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