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