ffmpeg_opt.c

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