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