1/* 2 * FFmpeg main 3 * Copyright (c) 2000-2003 Fabrice Bellard 4 * 5 * This file is part of FFmpeg. 6 * 7 * FFmpeg is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU Lesser General Public 9 * License as published by the Free Software Foundation; either 10 * version 2.1 of the License, or (at your option) any later version. 11 * 12 * FFmpeg is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * Lesser General Public License for more details. 16 * 17 * You should have received a copy of the GNU Lesser General Public 18 * License along with FFmpeg; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 20 */ 21 22/* needed for usleep() */ 23#define _XOPEN_SOURCE 600 24 25#include "config.h" 26#include <ctype.h> 27#include <string.h> 28#include <math.h> 29#include <stdlib.h> 30#include <errno.h> 31#include <signal.h> 32#include <limits.h> 33#include <unistd.h> 34#include "libavformat/avformat.h" 35#include "libavdevice/avdevice.h" 36#include "libswscale/swscale.h" 37#include "libavcodec/opt.h" 38#include "libavcodec/audioconvert.h" 39#include "libavcodec/colorspace.h" 40#include "libavutil/fifo.h" 41#include "libavutil/pixdesc.h" 42#include "libavutil/avstring.h" 43#include "libavutil/libm.h" 44#include "libavformat/os_support.h" 45 46#if HAVE_SYS_RESOURCE_H 47#include <sys/types.h> 48#include <sys/time.h> 49#include <sys/resource.h> 50#elif HAVE_GETPROCESSTIMES 51#include <windows.h> 52#endif 53#if HAVE_GETPROCESSMEMORYINFO 54#include <windows.h> 55#include <psapi.h> 56#endif 57 58#if HAVE_SYS_SELECT_H 59#include <sys/select.h> 60#endif 61 62#if HAVE_TERMIOS_H 63#include <fcntl.h> 64#include <sys/ioctl.h> 65#include <sys/time.h> 66#include <termios.h> 67#elif HAVE_CONIO_H 68#include <conio.h> 69#endif 70#include <time.h> 71 72#include "cmdutils.h" 73 74#undef NDEBUG 75#include <assert.h> 76 77const char program_name[] = "FFmpeg"; 78const int program_birth_year = 2000; 79 80/* select an input stream for an output stream */ 81typedef struct AVStreamMap { 82 int file_index; 83 int stream_index; 84 int sync_file_index; 85 int sync_stream_index; 86} AVStreamMap; 87 88/** select an input file for an output file */ 89typedef struct AVMetaDataMap { 90 int out_file; 91 int in_file; 92} AVMetaDataMap; 93 94static const OptionDef options[]; 95 96#define MAX_FILES 100 97 98static const char *last_asked_format = NULL; 99static AVFormatContext *input_files[MAX_FILES]; 100static int64_t input_files_ts_offset[MAX_FILES]; 101static double input_files_ts_scale[MAX_FILES][MAX_STREAMS]; 102static AVCodec *input_codecs[MAX_FILES*MAX_STREAMS]; 103static int nb_input_files = 0; 104static int nb_icodecs; 105 106static AVFormatContext *output_files[MAX_FILES]; 107static AVCodec *output_codecs[MAX_FILES*MAX_STREAMS]; 108static int nb_output_files = 0; 109static int nb_ocodecs; 110 111static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS]; 112static int nb_stream_maps; 113 114static AVMetaDataMap meta_data_maps[MAX_FILES]; 115static int nb_meta_data_maps; 116 117static int frame_width = 0; 118static int frame_height = 0; 119static float frame_aspect_ratio = 0; 120static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE; 121static enum SampleFormat audio_sample_fmt = SAMPLE_FMT_NONE; 122static int frame_padtop = 0; 123static int frame_padbottom = 0; 124static int frame_padleft = 0; 125static int frame_padright = 0; 126static int padcolor[3] = {16,128,128}; /* default to black */ 127static int frame_topBand = 0; 128static int frame_bottomBand = 0; 129static int frame_leftBand = 0; 130static int frame_rightBand = 0; 131static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX}; 132static AVRational frame_rate; 133static float video_qscale = 0; 134static uint16_t *intra_matrix = NULL; 135static uint16_t *inter_matrix = NULL; 136static const char *video_rc_override_string=NULL; 137static int video_disable = 0; 138static int video_discard = 0; 139static char *video_codec_name = NULL; 140static int video_codec_tag = 0; 141static char *video_language = NULL; 142static int same_quality = 0; 143static int do_deinterlace = 0; 144static int top_field_first = -1; 145static int me_threshold = 0; 146static int intra_dc_precision = 8; 147static int loop_input = 0; 148static int loop_output = AVFMT_NOOUTPUTLOOP; 149static int qp_hist = 0; 150 151static int intra_only = 0; 152static int audio_sample_rate = 44100; 153static int64_t channel_layout = 0; 154#define QSCALE_NONE -99999 155static float audio_qscale = QSCALE_NONE; 156static int audio_disable = 0; 157static int audio_channels = 1; 158static char *audio_codec_name = NULL; 159static int audio_codec_tag = 0; 160static char *audio_language = NULL; 161 162static int subtitle_disable = 0; 163static char *subtitle_codec_name = NULL; 164static char *subtitle_language = NULL; 165static int subtitle_codec_tag = 0; 166 167static float mux_preload= 0.5; 168static float mux_max_delay= 0.7; 169 170static int64_t recording_time = INT64_MAX; 171static int64_t start_time = 0; 172static int64_t rec_timestamp = 0; 173static int64_t input_ts_offset = 0; 174static int file_overwrite = 0; 175static int metadata_count; 176static AVMetadataTag *metadata; 177static int do_benchmark = 0; 178static int do_hex_dump = 0; 179static int do_pkt_dump = 0; 180static int do_psnr = 0; 181static int do_pass = 0; 182static char *pass_logfilename_prefix = NULL; 183static int audio_stream_copy = 0; 184static int video_stream_copy = 0; 185static int subtitle_stream_copy = 0; 186static int video_sync_method= -1; 187static int audio_sync_method= 0; 188static float audio_drift_threshold= 0.1; 189static int copy_ts= 0; 190static int opt_shortest = 0; 191static int video_global_header = 0; 192static char *vstats_filename; 193static FILE *vstats_file; 194static int opt_programid = 0; 195static int copy_initial_nonkeyframes = 0; 196 197static int rate_emu = 0; 198 199static int video_channel = 0; 200static char *video_standard; 201 202static int audio_volume = 256; 203 204static int exit_on_error = 0; 205static int using_stdin = 0; 206static int verbose = 1; 207static int thread_count= 1; 208static int q_pressed = 0; 209static int64_t video_size = 0; 210static int64_t audio_size = 0; 211static int64_t extra_size = 0; 212static int nb_frames_dup = 0; 213static int nb_frames_drop = 0; 214static int input_sync; 215static uint64_t limit_filesize = 0; 216static int force_fps = 0; 217 218static int pgmyuv_compatibility_hack=0; 219static float dts_delta_threshold = 10; 220 221static unsigned int sws_flags = SWS_BICUBIC; 222 223static int64_t timer_start; 224 225static uint8_t *audio_buf; 226static uint8_t *audio_out; 227unsigned int allocated_audio_out_size, allocated_audio_buf_size; 228 229static short *samples; 230 231static AVBitStreamFilterContext *video_bitstream_filters=NULL; 232static AVBitStreamFilterContext *audio_bitstream_filters=NULL; 233static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL; 234static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS]; 235 236#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass" 237 238struct AVInputStream; 239 240typedef struct AVOutputStream { 241 int file_index; /* file index */ 242 int index; /* stream index in the output file */ 243 int source_index; /* AVInputStream index */ 244 AVStream *st; /* stream in the output file */ 245 int encoding_needed; /* true if encoding needed for this stream */ 246 int frame_number; 247 /* input pts and corresponding output pts 248 for A/V sync */ 249 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */ 250 struct AVInputStream *sync_ist; /* input stream to sync against */ 251 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number 252 /* video only */ 253 int video_resample; 254 AVFrame pict_tmp; /* temporary image for resampling */ 255 struct SwsContext *img_resample_ctx; /* for image resampling */ 256 int resample_height; 257 int resample_width; 258 int resample_pix_fmt; 259 260 /* full frame size of first frame */ 261 int original_height; 262 int original_width; 263 264 /* cropping area sizes */ 265 int video_crop; 266 int topBand; 267 int bottomBand; 268 int leftBand; 269 int rightBand; 270 271 /* cropping area of first frame */ 272 int original_topBand; 273 int original_bottomBand; 274 int original_leftBand; 275 int original_rightBand; 276 277 /* padding area sizes */ 278 int video_pad; 279 int padtop; 280 int padbottom; 281 int padleft; 282 int padright; 283 284 /* audio only */ 285 int audio_resample; 286 ReSampleContext *resample; /* for audio resampling */ 287 int reformat_pair; 288 AVAudioConvert *reformat_ctx; 289 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */ 290 FILE *logfile; 291} AVOutputStream; 292 293typedef struct AVInputStream { 294 int file_index; 295 int index; 296 AVStream *st; 297 int discard; /* true if stream data should be discarded */ 298 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */ 299 int64_t sample_index; /* current sample */ 300 301 int64_t start; /* time when read started */ 302 int64_t next_pts; /* synthetic pts for cases where pkt.pts 303 is not defined */ 304 int64_t pts; /* current pts */ 305 int is_start; /* is 1 at the start and after a discontinuity */ 306 int showed_multi_packet_warning; 307 int is_past_recording_time; 308} AVInputStream; 309 310typedef struct AVInputFile { 311 int eof_reached; /* true if eof reached */ 312 int ist_index; /* index of first stream in ist_table */ 313 int buffer_size; /* current total buffer size */ 314 int nb_streams; /* nb streams we are aware of */ 315} AVInputFile; 316 317#if HAVE_TERMIOS_H 318 319/* init terminal so that we can grab keys */ 320static struct termios oldtty; 321#endif 322 323static void term_exit(void) 324{ 325#if HAVE_TERMIOS_H 326 tcsetattr (0, TCSANOW, &oldtty); 327#endif 328} 329 330static volatile int received_sigterm = 0; 331 332static void 333sigterm_handler(int sig) 334{ 335 received_sigterm = sig; 336 term_exit(); 337} 338 339static void term_init(void) 340{ 341#if HAVE_TERMIOS_H 342 struct termios tty; 343 344 tcgetattr (0, &tty); 345 oldtty = tty; 346 atexit(term_exit); 347 348 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP 349 |INLCR|IGNCR|ICRNL|IXON); 350 tty.c_oflag |= OPOST; 351 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN); 352 tty.c_cflag &= ~(CSIZE|PARENB); 353 tty.c_cflag |= CS8; 354 tty.c_cc[VMIN] = 1; 355 tty.c_cc[VTIME] = 0; 356 357 tcsetattr (0, TCSANOW, &tty); 358 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */ 359#endif 360 361 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */ 362 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */ 363#ifdef SIGXCPU 364 signal(SIGXCPU, sigterm_handler); 365#endif 366 367#if CONFIG_BEOS_NETSERVER 368 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK); 369#endif 370} 371 372/* read a key without blocking */ 373static int read_key(void) 374{ 375#if HAVE_TERMIOS_H 376 int n = 1; 377 unsigned char ch; 378#if !CONFIG_BEOS_NETSERVER 379 struct timeval tv; 380 fd_set rfds; 381 382 FD_ZERO(&rfds); 383 FD_SET(0, &rfds); 384 tv.tv_sec = 0; 385 tv.tv_usec = 0; 386 n = select(1, &rfds, NULL, NULL, &tv); 387#endif 388 if (n > 0) { 389 n = read(0, &ch, 1); 390 if (n == 1) 391 return ch; 392 393 return n; 394 } 395#elif HAVE_CONIO_H 396 if(kbhit()) 397 return(getch()); 398#endif 399 return -1; 400} 401 402static int decode_interrupt_cb(void) 403{ 404 return q_pressed || (q_pressed = read_key() == 'q'); 405} 406 407static int av_exit(int ret) 408{ 409 int i; 410 411 /* close files */ 412 for(i=0;i<nb_output_files;i++) { 413 /* maybe av_close_output_file ??? */ 414 AVFormatContext *s = output_files[i]; 415 int j; 416 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb) 417 url_fclose(s->pb); 418 for(j=0;j<s->nb_streams;j++) { 419 av_metadata_free(&s->streams[j]->metadata); 420 av_free(s->streams[j]->codec); 421 av_free(s->streams[j]); 422 } 423 for(j=0;j<s->nb_programs;j++) { 424 av_metadata_free(&s->programs[j]->metadata); 425 } 426 for(j=0;j<s->nb_chapters;j++) { 427 av_metadata_free(&s->chapters[j]->metadata); 428 } 429 av_metadata_free(&s->metadata); 430 av_free(s); 431 } 432 for(i=0;i<nb_input_files;i++) 433 av_close_input_file(input_files[i]); 434 435 av_free(intra_matrix); 436 av_free(inter_matrix); 437 438 if (vstats_file) 439 fclose(vstats_file); 440 av_free(vstats_filename); 441 442 av_free(opt_names); 443 444 av_free(video_codec_name); 445 av_free(audio_codec_name); 446 av_free(subtitle_codec_name); 447 448 av_free(video_standard); 449 450#if CONFIG_POWERPC_PERF 451 void powerpc_display_perf_report(void); 452 powerpc_display_perf_report(); 453#endif /* CONFIG_POWERPC_PERF */ 454 455 for (i=0;i<AVMEDIA_TYPE_NB;i++) 456 av_free(avcodec_opts[i]); 457 av_free(avformat_opts); 458 av_free(sws_opts); 459 av_free(audio_buf); 460 av_free(audio_out); 461 allocated_audio_buf_size= allocated_audio_out_size= 0; 462 av_free(samples); 463 464 if (received_sigterm) { 465 fprintf(stderr, 466 "Received signal %d: terminating.\n", 467 (int) received_sigterm); 468 exit (255); 469 } 470 471 exit(ret); /* not all OS-es handle main() return value */ 472 return ret; 473} 474 475static void choose_sample_fmt(AVStream *st, AVCodec *codec) 476{ 477 if(codec && codec->sample_fmts){ 478 const enum SampleFormat *p= codec->sample_fmts; 479 for(; *p!=-1; p++){ 480 if(*p == st->codec->sample_fmt) 481 break; 482 } 483 if(*p == -1) 484 st->codec->sample_fmt = codec->sample_fmts[0]; 485 } 486} 487 488static void choose_sample_rate(AVStream *st, AVCodec *codec) 489{ 490 if(codec && codec->supported_samplerates){ 491 const int *p= codec->supported_samplerates; 492 int best; 493 int best_dist=INT_MAX; 494 for(; *p; p++){ 495 int dist= abs(st->codec->sample_rate - *p); 496 if(dist < best_dist){ 497 best_dist= dist; 498 best= *p; 499 } 500 } 501 if(best_dist){ 502 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best); 503 } 504 st->codec->sample_rate= best; 505 } 506} 507 508static void choose_pixel_fmt(AVStream *st, AVCodec *codec) 509{ 510 if(codec && codec->pix_fmts){ 511 const enum PixelFormat *p= codec->pix_fmts; 512 for(; *p!=-1; p++){ 513 if(*p == st->codec->pix_fmt) 514 break; 515 } 516 if(*p == -1 517 && !( st->codec->codec_id==CODEC_ID_MJPEG 518 && st->codec->strict_std_compliance <= FF_COMPLIANCE_INOFFICIAL 519 && ( st->codec->pix_fmt == PIX_FMT_YUV420P 520 || st->codec->pix_fmt == PIX_FMT_YUV422P))) 521 st->codec->pix_fmt = codec->pix_fmts[0]; 522 } 523} 524 525static int read_ffserver_streams(AVFormatContext *s, const char *filename) 526{ 527 int i, err; 528 AVFormatContext *ic; 529 int nopts = 0; 530 531 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL); 532 if (err < 0) 533 return err; 534 /* copy stream format */ 535 s->nb_streams = ic->nb_streams; 536 for(i=0;i<ic->nb_streams;i++) { 537 AVStream *st; 538 AVCodec *codec; 539 540 // FIXME: a more elegant solution is needed 541 st = av_mallocz(sizeof(AVStream)); 542 memcpy(st, ic->streams[i], sizeof(AVStream)); 543 st->codec = avcodec_alloc_context(); 544 if (!st->codec) { 545 print_error(filename, AVERROR(ENOMEM)); 546 av_exit(1); 547 } 548 avcodec_copy_context(st->codec, ic->streams[i]->codec); 549 s->streams[i] = st; 550 551 codec = avcodec_find_encoder(st->codec->codec_id); 552 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) { 553 if (audio_stream_copy) { 554 st->stream_copy = 1; 555 } else 556 choose_sample_fmt(st, codec); 557 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) { 558 if (video_stream_copy) { 559 st->stream_copy = 1; 560 } else 561 choose_pixel_fmt(st, codec); 562 } 563 564 if(!st->codec->thread_count) 565 st->codec->thread_count = 1; 566 if(st->codec->thread_count>1) 567 avcodec_thread_init(st->codec, st->codec->thread_count); 568 569 if(st->codec->flags & CODEC_FLAG_BITEXACT) 570 nopts = 1; 571 } 572 573 if (!nopts) 574 s->timestamp = av_gettime(); 575 576 av_close_input_file(ic); 577 return 0; 578} 579 580static double 581get_sync_ipts(const AVOutputStream *ost) 582{ 583 const AVInputStream *ist = ost->sync_ist; 584 return (double)(ist->pts - start_time)/AV_TIME_BASE; 585} 586 587static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){ 588 int ret; 589 590 while(bsfc){ 591 AVPacket new_pkt= *pkt; 592 int a= av_bitstream_filter_filter(bsfc, avctx, NULL, 593 &new_pkt.data, &new_pkt.size, 594 pkt->data, pkt->size, 595 pkt->flags & AV_PKT_FLAG_KEY); 596 if(a>0){ 597 av_free_packet(pkt); 598 new_pkt.destruct= av_destruct_packet; 599 } else if(a<0){ 600 fprintf(stderr, "%s failed for stream %d, codec %s", 601 bsfc->filter->name, pkt->stream_index, 602 avctx->codec ? avctx->codec->name : "copy"); 603 print_error("", a); 604 if (exit_on_error) 605 av_exit(1); 606 } 607 *pkt= new_pkt; 608 609 bsfc= bsfc->next; 610 } 611 612 ret= av_interleaved_write_frame(s, pkt); 613 if(ret < 0){ 614 print_error("av_interleaved_write_frame()", ret); 615 av_exit(1); 616 } 617} 618 619#define MAX_AUDIO_PACKET_SIZE (128 * 1024) 620 621static void do_audio_out(AVFormatContext *s, 622 AVOutputStream *ost, 623 AVInputStream *ist, 624 unsigned char *buf, int size) 625{ 626 uint8_t *buftmp; 627 int64_t audio_out_size, audio_buf_size; 628 int64_t allocated_for_size= size; 629 630 int size_out, frame_bytes, ret; 631 AVCodecContext *enc= ost->st->codec; 632 AVCodecContext *dec= ist->st->codec; 633 int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8; 634 int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8; 635 const int coded_bps = av_get_bits_per_sample(enc->codec->id); 636 637need_realloc: 638 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels); 639 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate; 640 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API 641 audio_buf_size*= osize*enc->channels; 642 643 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels); 644 if(coded_bps > 8*osize) 645 audio_out_size= audio_out_size * coded_bps / (8*osize); 646 audio_out_size += FF_MIN_BUFFER_SIZE; 647 648 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){ 649 fprintf(stderr, "Buffer sizes too large\n"); 650 av_exit(1); 651 } 652 653 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size); 654 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size); 655 if (!audio_buf || !audio_out){ 656 fprintf(stderr, "Out of memory in do_audio_out\n"); 657 av_exit(1); 658 } 659 660 if (enc->channels != dec->channels) 661 ost->audio_resample = 1; 662 663 if (ost->audio_resample && !ost->resample) { 664 if (dec->sample_fmt != SAMPLE_FMT_S16) 665 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n"); 666 ost->resample = av_audio_resample_init(enc->channels, dec->channels, 667 enc->sample_rate, dec->sample_rate, 668 enc->sample_fmt, dec->sample_fmt, 669 16, 10, 0, 0.8); 670 if (!ost->resample) { 671 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n", 672 dec->channels, dec->sample_rate, 673 enc->channels, enc->sample_rate); 674 av_exit(1); 675 } 676 } 677 678#define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b)) 679 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt && 680 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) { 681 if (ost->reformat_ctx) 682 av_audio_convert_free(ost->reformat_ctx); 683 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1, 684 dec->sample_fmt, 1, NULL, 0); 685 if (!ost->reformat_ctx) { 686 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n", 687 avcodec_get_sample_fmt_name(dec->sample_fmt), 688 avcodec_get_sample_fmt_name(enc->sample_fmt)); 689 av_exit(1); 690 } 691 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt); 692 } 693 694 if(audio_sync_method){ 695 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts 696 - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2); 697 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate; 698 int byte_delta= ((int)idelta)*2*ist->st->codec->channels; 699 700 //FIXME resample delay 701 if(fabs(delta) > 50){ 702 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){ 703 if(byte_delta < 0){ 704 byte_delta= FFMAX(byte_delta, -size); 705 size += byte_delta; 706 buf -= byte_delta; 707 if(verbose > 2) 708 fprintf(stderr, "discarding %d audio samples\n", (int)-delta); 709 if(!size) 710 return; 711 ist->is_start=0; 712 }else{ 713 static uint8_t *input_tmp= NULL; 714 input_tmp= av_realloc(input_tmp, byte_delta + size); 715 716 if(byte_delta > allocated_for_size - size){ 717 allocated_for_size= byte_delta + (int64_t)size; 718 goto need_realloc; 719 } 720 ist->is_start=0; 721 722 memset(input_tmp, 0, byte_delta); 723 memcpy(input_tmp + byte_delta, buf, size); 724 buf= input_tmp; 725 size += byte_delta; 726 if(verbose > 2) 727 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta); 728 } 729 }else if(audio_sync_method>1){ 730 int comp= av_clip(delta, -audio_sync_method, audio_sync_method); 731 assert(ost->audio_resample); 732 if(verbose > 2) 733 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate); 734// fprintf(stderr, "drift:%f len:%d opts:%"PRId64" ipts:%"PRId64" fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2)); 735 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate); 736 } 737 } 738 }else 739 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate) 740 - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong 741 742 if (ost->audio_resample) { 743 buftmp = audio_buf; 744 size_out = audio_resample(ost->resample, 745 (short *)buftmp, (short *)buf, 746 size / (ist->st->codec->channels * isize)); 747 size_out = size_out * enc->channels * osize; 748 } else { 749 buftmp = buf; 750 size_out = size; 751 } 752 753 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) { 754 const void *ibuf[6]= {buftmp}; 755 void *obuf[6]= {audio_buf}; 756 int istride[6]= {isize}; 757 int ostride[6]= {osize}; 758 int len= size_out/istride[0]; 759 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) { 760 printf("av_audio_convert() failed\n"); 761 if (exit_on_error) 762 av_exit(1); 763 return; 764 } 765 buftmp = audio_buf; 766 size_out = len*osize; 767 } 768 769 /* now encode as many frames as possible */ 770 if (enc->frame_size > 1) { 771 /* output resampled raw samples */ 772 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) { 773 fprintf(stderr, "av_fifo_realloc2() failed\n"); 774 av_exit(1); 775 } 776 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL); 777 778 frame_bytes = enc->frame_size * osize * enc->channels; 779 780 while (av_fifo_size(ost->fifo) >= frame_bytes) { 781 AVPacket pkt; 782 av_init_packet(&pkt); 783 784 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL); 785 786 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio() 787 788 ret = avcodec_encode_audio(enc, audio_out, audio_out_size, 789 (short *)audio_buf); 790 if (ret < 0) { 791 fprintf(stderr, "Audio encoding failed\n"); 792 av_exit(1); 793 } 794 audio_size += ret; 795 pkt.stream_index= ost->index; 796 pkt.data= audio_out; 797 pkt.size= ret; 798 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE) 799 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base); 800 pkt.flags |= AV_PKT_FLAG_KEY; 801 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]); 802 803 ost->sync_opts += enc->frame_size; 804 } 805 } else { 806 AVPacket pkt; 807 av_init_packet(&pkt); 808 809 ost->sync_opts += size_out / (osize * enc->channels); 810 811 /* output a pcm frame */ 812 /* determine the size of the coded buffer */ 813 size_out /= osize; 814 if (coded_bps) 815 size_out = size_out*coded_bps/8; 816 817 if(size_out > audio_out_size){ 818 fprintf(stderr, "Internal error, buffer size too small\n"); 819 av_exit(1); 820 } 821 822 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio() 823 ret = avcodec_encode_audio(enc, audio_out, size_out, 824 (short *)buftmp); 825 if (ret < 0) { 826 fprintf(stderr, "Audio encoding failed\n"); 827 av_exit(1); 828 } 829 audio_size += ret; 830 pkt.stream_index= ost->index; 831 pkt.data= audio_out; 832 pkt.size= ret; 833 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE) 834 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base); 835 pkt.flags |= AV_PKT_FLAG_KEY; 836 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]); 837 } 838} 839 840static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp) 841{ 842 AVCodecContext *dec; 843 AVPicture *picture2; 844 AVPicture picture_tmp; 845 uint8_t *buf = 0; 846 847 dec = ist->st->codec; 848 849 /* deinterlace : must be done before any resize */ 850 if (do_deinterlace) { 851 int size; 852 853 /* create temporary picture */ 854 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height); 855 buf = av_malloc(size); 856 if (!buf) 857 return; 858 859 picture2 = &picture_tmp; 860 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height); 861 862 if(avpicture_deinterlace(picture2, picture, 863 dec->pix_fmt, dec->width, dec->height) < 0) { 864 /* if error, do not deinterlace */ 865 fprintf(stderr, "Deinterlacing failed\n"); 866 av_free(buf); 867 buf = NULL; 868 picture2 = picture; 869 } 870 } else { 871 picture2 = picture; 872 } 873 874 if (picture != picture2) 875 *picture = *picture2; 876 *bufp = buf; 877} 878 879/* we begin to correct av delay at this threshold */ 880#define AV_DELAY_MAX 0.100 881 882static void do_subtitle_out(AVFormatContext *s, 883 AVOutputStream *ost, 884 AVInputStream *ist, 885 AVSubtitle *sub, 886 int64_t pts) 887{ 888 static uint8_t *subtitle_out = NULL; 889 int subtitle_out_max_size = 1024 * 1024; 890 int subtitle_out_size, nb, i; 891 AVCodecContext *enc; 892 AVPacket pkt; 893 894 if (pts == AV_NOPTS_VALUE) { 895 fprintf(stderr, "Subtitle packets must have a pts\n"); 896 if (exit_on_error) 897 av_exit(1); 898 return; 899 } 900 901 enc = ost->st->codec; 902 903 if (!subtitle_out) { 904 subtitle_out = av_malloc(subtitle_out_max_size); 905 } 906 907 /* Note: DVB subtitle need one packet to draw them and one other 908 packet to clear them */ 909 /* XXX: signal it in the codec context ? */ 910 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) 911 nb = 2; 912 else 913 nb = 1; 914 915 for(i = 0; i < nb; i++) { 916 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q); 917 // start_display_time is required to be 0 918 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q); 919 sub->end_display_time -= sub->start_display_time; 920 sub->start_display_time = 0; 921 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out, 922 subtitle_out_max_size, sub); 923 if (subtitle_out_size < 0) { 924 fprintf(stderr, "Subtitle encoding failed\n"); 925 av_exit(1); 926 } 927 928 av_init_packet(&pkt); 929 pkt.stream_index = ost->index; 930 pkt.data = subtitle_out; 931 pkt.size = subtitle_out_size; 932 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base); 933 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) { 934 /* XXX: the pts correction is handled here. Maybe handling 935 it in the codec would be better */ 936 if (i == 0) 937 pkt.pts += 90 * sub->start_display_time; 938 else 939 pkt.pts += 90 * sub->end_display_time; 940 } 941 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]); 942 } 943} 944 945static int bit_buffer_size= 1024*256; 946static uint8_t *bit_buffer= NULL; 947 948static void do_video_out(AVFormatContext *s, 949 AVOutputStream *ost, 950 AVInputStream *ist, 951 AVFrame *in_picture, 952 int *frame_size) 953{ 954 int nb_frames, i, ret; 955 int64_t topBand, bottomBand, leftBand, rightBand; 956 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src; 957 AVFrame picture_crop_temp, picture_pad_temp; 958 AVCodecContext *enc, *dec; 959 double sync_ipts; 960 961 avcodec_get_frame_defaults(&picture_crop_temp); 962 avcodec_get_frame_defaults(&picture_pad_temp); 963 964 enc = ost->st->codec; 965 dec = ist->st->codec; 966 967 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base); 968 969 /* by default, we output a single frame */ 970 nb_frames = 1; 971 972 *frame_size = 0; 973 974 if(video_sync_method){ 975 double vdelta = sync_ipts - ost->sync_opts; 976 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c 977 if (vdelta < -1.1) 978 nb_frames = 0; 979 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){ 980 if(vdelta<=-0.6){ 981 nb_frames=0; 982 }else if(vdelta>0.6) 983 ost->sync_opts= lrintf(sync_ipts); 984 }else if (vdelta > 1.1) 985 nb_frames = lrintf(vdelta); 986//fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, get_sync_ipts(ost), nb_frames); 987 if (nb_frames == 0){ 988 ++nb_frames_drop; 989 if (verbose>2) 990 fprintf(stderr, "*** drop!\n"); 991 }else if (nb_frames > 1) { 992 nb_frames_dup += nb_frames - 1; 993 if (verbose>2) 994 fprintf(stderr, "*** %d dup!\n", nb_frames-1); 995 } 996 }else 997 ost->sync_opts= lrintf(sync_ipts); 998 999 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number); 1000 if (nb_frames <= 0) 1001 return; 1002 1003 if (ost->video_crop) { 1004 if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) { 1005 fprintf(stderr, "error cropping picture\n"); 1006 if (exit_on_error) 1007 av_exit(1); 1008 return; 1009 } 1010 formatted_picture = &picture_crop_temp; 1011 } else { 1012 formatted_picture = in_picture; 1013 } 1014 1015 final_picture = formatted_picture; 1016 padding_src = formatted_picture; 1017 resampling_dst = &ost->pict_tmp; 1018 if (ost->video_pad) { 1019 final_picture = &ost->pict_tmp; 1020 if (ost->video_resample) { 1021 if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) { 1022 fprintf(stderr, "error padding picture\n"); 1023 if (exit_on_error) 1024 av_exit(1); 1025 return; 1026 } 1027 resampling_dst = &picture_pad_temp; 1028 } 1029 } 1030 1031 if( (ost->resample_height != (ist->st->codec->height - (ost->topBand + ost->bottomBand))) 1032 || (ost->resample_width != (ist->st->codec->width - (ost->leftBand + ost->rightBand))) 1033 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) { 1034 1035 fprintf(stderr,"Input Stream #%d.%d frame size changed to %dx%d, %s\n", ist->file_index, ist->index, ist->st->codec->width, ist->st->codec->height,avcodec_get_pix_fmt_name(ist->st->codec->pix_fmt)); 1036 if(!ost->video_resample) 1037 av_exit(1); 1038 } 1039 1040 if (ost->video_resample) { 1041 padding_src = NULL; 1042 final_picture = &ost->pict_tmp; 1043 if( (ost->resample_height != (ist->st->codec->height - (ost->topBand + ost->bottomBand))) 1044 || (ost->resample_width != (ist->st->codec->width - (ost->leftBand + ost->rightBand))) 1045 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) { 1046 1047 /* keep bands proportional to the frame size */ 1048 topBand = ((int64_t)ist->st->codec->height * ost->original_topBand / ost->original_height) & ~1; 1049 bottomBand = ((int64_t)ist->st->codec->height * ost->original_bottomBand / ost->original_height) & ~1; 1050 leftBand = ((int64_t)ist->st->codec->width * ost->original_leftBand / ost->original_width) & ~1; 1051 rightBand = ((int64_t)ist->st->codec->width * ost->original_rightBand / ost->original_width) & ~1; 1052 1053 /* sanity check to ensure no bad band sizes sneak in */ 1054 assert(topBand <= INT_MAX && topBand >= 0); 1055 assert(bottomBand <= INT_MAX && bottomBand >= 0); 1056 assert(leftBand <= INT_MAX && leftBand >= 0); 1057 assert(rightBand <= INT_MAX && rightBand >= 0); 1058 1059 ost->topBand = topBand; 1060 ost->bottomBand = bottomBand; 1061 ost->leftBand = leftBand; 1062 ost->rightBand = rightBand; 1063 1064 ost->resample_height = ist->st->codec->height - (ost->topBand + ost->bottomBand); 1065 ost->resample_width = ist->st->codec->width - (ost->leftBand + ost->rightBand); 1066 ost->resample_pix_fmt= ist->st->codec->pix_fmt; 1067 1068 /* initialize a new scaler context */ 1069 sws_freeContext(ost->img_resample_ctx); 1070 sws_flags = av_get_int(sws_opts, "sws_flags", NULL); 1071 ost->img_resample_ctx = sws_getContext( 1072 ist->st->codec->width - (ost->leftBand + ost->rightBand), 1073 ist->st->codec->height - (ost->topBand + ost->bottomBand), 1074 ist->st->codec->pix_fmt, 1075 ost->st->codec->width - (ost->padleft + ost->padright), 1076 ost->st->codec->height - (ost->padtop + ost->padbottom), 1077 ost->st->codec->pix_fmt, 1078 sws_flags, NULL, NULL, NULL); 1079 if (ost->img_resample_ctx == NULL) { 1080 fprintf(stderr, "Cannot get resampling context\n"); 1081 av_exit(1); 1082 } 1083 } 1084 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize, 1085 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize); 1086 } 1087 1088 if (ost->video_pad) { 1089 av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src, 1090 enc->height, enc->width, enc->pix_fmt, 1091 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor); 1092 } 1093 1094 /* duplicates frame if needed */ 1095 for(i=0;i<nb_frames;i++) { 1096 AVPacket pkt; 1097 av_init_packet(&pkt); 1098 pkt.stream_index= ost->index; 1099 1100 if (s->oformat->flags & AVFMT_RAWPICTURE) { 1101 /* raw pictures are written as AVPicture structure to 1102 avoid any copies. We support temorarily the older 1103 method. */ 1104 AVFrame* old_frame = enc->coded_frame; 1105 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack 1106 pkt.data= (uint8_t *)final_picture; 1107 pkt.size= sizeof(AVPicture); 1108 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base); 1109 pkt.flags |= AV_PKT_FLAG_KEY; 1110 1111 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]); 1112 enc->coded_frame = old_frame; 1113 } else { 1114 AVFrame big_picture; 1115 1116 big_picture= *final_picture; 1117 /* better than nothing: use input picture interlaced 1118 settings */ 1119 big_picture.interlaced_frame = in_picture->interlaced_frame; 1120 if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){ 1121 if(top_field_first == -1) 1122 big_picture.top_field_first = in_picture->top_field_first; 1123 else 1124 big_picture.top_field_first = top_field_first; 1125 } 1126 1127 /* handles sameq here. This is not correct because it may 1128 not be a global option */ 1129 if (same_quality) { 1130 big_picture.quality = ist->st->quality; 1131 }else 1132 big_picture.quality = ost->st->quality; 1133 if(!me_threshold) 1134 big_picture.pict_type = 0; 1135// big_picture.pts = AV_NOPTS_VALUE; 1136 big_picture.pts= ost->sync_opts; 1137// big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den); 1138//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts); 1139 ret = avcodec_encode_video(enc, 1140 bit_buffer, bit_buffer_size, 1141 &big_picture); 1142 if (ret < 0) { 1143 fprintf(stderr, "Video encoding failed\n"); 1144 av_exit(1); 1145 } 1146 1147 if(ret>0){ 1148 pkt.data= bit_buffer; 1149 pkt.size= ret; 1150 if(enc->coded_frame->pts != AV_NOPTS_VALUE) 1151 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base); 1152/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n", 1153 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1, 1154 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/ 1155 1156 if(enc->coded_frame->key_frame) 1157 pkt.flags |= AV_PKT_FLAG_KEY; 1158 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]); 1159 *frame_size = ret; 1160 video_size += ret; 1161 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d", 1162 // enc->frame_number-1, ret, enc->pict_type); 1163 /* if two pass, output log */ 1164 if (ost->logfile && enc->stats_out) { 1165 fprintf(ost->logfile, "%s", enc->stats_out); 1166 } 1167 } 1168 } 1169 ost->sync_opts++; 1170 ost->frame_number++; 1171 } 1172} 1173 1174static double psnr(double d){ 1175 return -10.0*log(d)/log(10.0); 1176} 1177 1178static void do_video_stats(AVFormatContext *os, AVOutputStream *ost, 1179 int frame_size) 1180{ 1181 AVCodecContext *enc; 1182 int frame_number; 1183 double ti1, bitrate, avg_bitrate; 1184 1185 /* this is executed just the first time do_video_stats is called */ 1186 if (!vstats_file) { 1187 vstats_file = fopen(vstats_filename, "w"); 1188 if (!vstats_file) { 1189 perror("fopen"); 1190 av_exit(1); 1191 } 1192 } 1193 1194 enc = ost->st->codec; 1195 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) { 1196 frame_number = ost->frame_number; 1197 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA); 1198 if (enc->flags&CODEC_FLAG_PSNR) 1199 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0))); 1200 1201 fprintf(vstats_file,"f_size= %6d ", frame_size); 1202 /* compute pts value */ 1203 ti1 = ost->sync_opts * av_q2d(enc->time_base); 1204 if (ti1 < 0.01) 1205 ti1 = 0.01; 1206 1207 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0; 1208 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0; 1209 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ", 1210 (double)video_size / 1024, ti1, bitrate, avg_bitrate); 1211 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type)); 1212 } 1213} 1214 1215static void print_report(AVFormatContext **output_files, 1216 AVOutputStream **ost_table, int nb_ostreams, 1217 int is_last_report) 1218{ 1219 char buf[1024]; 1220 AVOutputStream *ost; 1221 AVFormatContext *oc; 1222 int64_t total_size; 1223 AVCodecContext *enc; 1224 int frame_number, vid, i; 1225 double bitrate, ti1, pts; 1226 static int64_t last_time = -1; 1227 static int qp_histogram[52]; 1228 1229 if (!is_last_report) { 1230 int64_t cur_time; 1231 /* display the report every 0.5 seconds */ 1232 cur_time = av_gettime(); 1233 if (last_time == -1) { 1234 last_time = cur_time; 1235 return; 1236 } 1237 if ((cur_time - last_time) < 500000) 1238 return; 1239 last_time = cur_time; 1240 } 1241 1242 1243 oc = output_files[0]; 1244 1245 total_size = url_fsize(oc->pb); 1246 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too 1247 total_size= url_ftell(oc->pb); 1248 1249 buf[0] = '\0'; 1250 ti1 = 1e10; 1251 vid = 0; 1252 for(i=0;i<nb_ostreams;i++) { 1253 ost = ost_table[i]; 1254 enc = ost->st->codec; 1255 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) { 1256 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", 1257 !ost->st->stream_copy ? 1258 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1); 1259 } 1260 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) { 1261 float t = (av_gettime()-timer_start) / 1000000.0; 1262 1263 frame_number = ost->frame_number; 1264 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ", 1265 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, 1266 !ost->st->stream_copy ? 1267 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1); 1268 if(is_last_report) 1269 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L"); 1270 if(qp_hist){ 1271 int j; 1272 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA); 1273 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram)) 1274 qp_histogram[qp]++; 1275 for(j=0; j<32; j++) 1276 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2))); 1277 } 1278 if (enc->flags&CODEC_FLAG_PSNR){ 1279 int j; 1280 double error, error_sum=0; 1281 double scale, scale_sum=0; 1282 char type[3]= {'Y','U','V'}; 1283 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR="); 1284 for(j=0; j<3; j++){ 1285 if(is_last_report){ 1286 error= enc->error[j]; 1287 scale= enc->width*enc->height*255.0*255.0*frame_number; 1288 }else{ 1289 error= enc->coded_frame->error[j]; 1290 scale= enc->width*enc->height*255.0*255.0; 1291 } 1292 if(j) scale/=4; 1293 error_sum += error; 1294 scale_sum += scale; 1295 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale)); 1296 } 1297 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum)); 1298 } 1299 vid = 1; 1300 } 1301 /* compute min output value */ 1302 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base); 1303 if ((pts < ti1) && (pts > 0)) 1304 ti1 = pts; 1305 } 1306 if (ti1 < 0.01) 1307 ti1 = 0.01; 1308 1309 if (verbose || is_last_report) { 1310 bitrate = (double)(total_size * 8) / ti1 / 1000.0; 1311 1312 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), 1313 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s", 1314 (double)total_size / 1024, ti1, bitrate); 1315 1316 if (nb_frames_dup || nb_frames_drop) 1317 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d", 1318 nb_frames_dup, nb_frames_drop); 1319 1320 if (verbose >= 0) 1321 fprintf(stderr, "%s \r", buf); 1322 1323 fflush(stderr); 1324 } 1325 1326 if (is_last_report && verbose >= 0){ 1327 int64_t raw= audio_size + video_size + extra_size; 1328 fprintf(stderr, "\n"); 1329 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n", 1330 video_size/1024.0, 1331 audio_size/1024.0, 1332 extra_size/1024.0, 1333 100.0*(total_size - raw)/raw 1334 ); 1335 } 1336} 1337 1338/* pkt = NULL means EOF (needed to flush decoder buffers) */ 1339static int output_packet(AVInputStream *ist, int ist_index, 1340 AVOutputStream **ost_table, int nb_ostreams, 1341 const AVPacket *pkt) 1342{ 1343 AVFormatContext *os; 1344 AVOutputStream *ost; 1345 int ret, i; 1346 int got_picture; 1347 AVFrame picture; 1348 void *buffer_to_free; 1349 static unsigned int samples_size= 0; 1350 AVSubtitle subtitle, *subtitle_to_free; 1351 int got_subtitle; 1352 AVPacket avpkt; 1353 int bps = av_get_bits_per_sample_format(ist->st->codec->sample_fmt)>>3; 1354 1355 if(ist->next_pts == AV_NOPTS_VALUE) 1356 ist->next_pts= ist->pts; 1357 1358 if (pkt == NULL) { 1359 /* EOF handling */ 1360 av_init_packet(&avpkt); 1361 avpkt.data = NULL; 1362 avpkt.size = 0; 1363 goto handle_eof; 1364 } else { 1365 avpkt = *pkt; 1366 } 1367 1368 if(pkt->dts != AV_NOPTS_VALUE) 1369 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q); 1370 1371 //while we have more to decode or while the decoder did output something on EOF 1372 while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) { 1373 uint8_t *data_buf, *decoded_data_buf; 1374 int data_size, decoded_data_size; 1375 handle_eof: 1376 ist->pts= ist->next_pts; 1377 1378 if(avpkt.size && avpkt.size != pkt->size && 1379 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){ 1380 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index); 1381 ist->showed_multi_packet_warning=1; 1382 } 1383 1384 /* decode the packet if needed */ 1385 decoded_data_buf = NULL; /* fail safe */ 1386 decoded_data_size= 0; 1387 data_buf = avpkt.data; 1388 data_size = avpkt.size; 1389 subtitle_to_free = NULL; 1390 if (ist->decoding_needed) { 1391 switch(ist->st->codec->codec_type) { 1392 case AVMEDIA_TYPE_AUDIO:{ 1393 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) { 1394 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE); 1395 av_free(samples); 1396 samples= av_malloc(samples_size); 1397 } 1398 decoded_data_size= samples_size; 1399 /* XXX: could avoid copy if PCM 16 bits with same 1400 endianness as CPU */ 1401 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size, 1402 &avpkt); 1403 if (ret < 0) 1404 goto fail_decode; 1405 avpkt.data += ret; 1406 avpkt.size -= ret; 1407 data_size = ret; 1408 /* Some bug in mpeg audio decoder gives */ 1409 /* decoded_data_size < 0, it seems they are overflows */ 1410 if (decoded_data_size <= 0) { 1411 /* no audio frame */ 1412 continue; 1413 } 1414 decoded_data_buf = (uint8_t *)samples; 1415 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) / 1416 (ist->st->codec->sample_rate * ist->st->codec->channels); 1417 break;} 1418 case AVMEDIA_TYPE_VIDEO: 1419 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2; 1420 /* XXX: allocate picture correctly */ 1421 avcodec_get_frame_defaults(&picture); 1422 1423 ret = avcodec_decode_video2(ist->st->codec, 1424 &picture, &got_picture, &avpkt); 1425 ist->st->quality= picture.quality; 1426 if (ret < 0) 1427 goto fail_decode; 1428 if (!got_picture) { 1429 /* no picture yet */ 1430 goto discard_packet; 1431 } 1432 if (ist->st->codec->time_base.num != 0) { 1433 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame; 1434 ist->next_pts += ((int64_t)AV_TIME_BASE * 1435 ist->st->codec->time_base.num * ticks) / 1436 ist->st->codec->time_base.den; 1437 } 1438 avpkt.size = 0; 1439 break; 1440 case AVMEDIA_TYPE_SUBTITLE: 1441 ret = avcodec_decode_subtitle2(ist->st->codec, 1442 &subtitle, &got_subtitle, &avpkt); 1443 if (ret < 0) 1444 goto fail_decode; 1445 if (!got_subtitle) { 1446 goto discard_packet; 1447 } 1448 subtitle_to_free = &subtitle; 1449 avpkt.size = 0; 1450 break; 1451 default: 1452 goto fail_decode; 1453 } 1454 } else { 1455 switch(ist->st->codec->codec_type) { 1456 case AVMEDIA_TYPE_AUDIO: 1457 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) / 1458 ist->st->codec->sample_rate; 1459 break; 1460 case AVMEDIA_TYPE_VIDEO: 1461 if (ist->st->codec->time_base.num != 0) { 1462 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame; 1463 ist->next_pts += ((int64_t)AV_TIME_BASE * 1464 ist->st->codec->time_base.num * ticks) / 1465 ist->st->codec->time_base.den; 1466 } 1467 break; 1468 } 1469 ret = avpkt.size; 1470 avpkt.size = 0; 1471 } 1472 1473 buffer_to_free = NULL; 1474 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) { 1475 pre_process_video_frame(ist, (AVPicture *)&picture, 1476 &buffer_to_free); 1477 } 1478 1479 // preprocess audio (volume) 1480 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) { 1481 if (audio_volume != 256) { 1482 short *volp; 1483 volp = samples; 1484 for(i=0;i<(decoded_data_size / sizeof(short));i++) { 1485 int v = ((*volp) * audio_volume + 128) >> 8; 1486 if (v < -32768) v = -32768; 1487 if (v > 32767) v = 32767; 1488 *volp++ = v; 1489 } 1490 } 1491 } 1492 1493 /* frame rate emulation */ 1494 if (rate_emu) { 1495 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE); 1496 int64_t now = av_gettime() - ist->start; 1497 if (pts > now) 1498 usleep(pts - now); 1499 } 1500 1501 /* if output time reached then transcode raw format, 1502 encode packets and output them */ 1503 if (start_time == 0 || ist->pts >= start_time) 1504 for(i=0;i<nb_ostreams;i++) { 1505 int frame_size; 1506 1507 ost = ost_table[i]; 1508 if (ost->source_index == ist_index) { 1509 os = output_files[ost->file_index]; 1510 1511 /* set the input output pts pairs */ 1512 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE; 1513 1514 if (ost->encoding_needed) { 1515 assert(ist->decoding_needed); 1516 switch(ost->st->codec->codec_type) { 1517 case AVMEDIA_TYPE_AUDIO: 1518 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size); 1519 break; 1520 case AVMEDIA_TYPE_VIDEO: 1521 do_video_out(os, ost, ist, &picture, &frame_size); 1522 if (vstats_filename && frame_size) 1523 do_video_stats(os, ost, frame_size); 1524 break; 1525 case AVMEDIA_TYPE_SUBTITLE: 1526 do_subtitle_out(os, ost, ist, &subtitle, 1527 pkt->pts); 1528 break; 1529 default: 1530 abort(); 1531 } 1532 } else { 1533 AVFrame avframe; //FIXME/XXX remove this 1534 AVPacket opkt; 1535 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base); 1536 1537 av_init_packet(&opkt); 1538 1539 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes) 1540 continue; 1541 1542 /* no reencoding needed : output the packet directly */ 1543 /* force the input stream PTS */ 1544 1545 avcodec_get_frame_defaults(&avframe); 1546 ost->st->codec->coded_frame= &avframe; 1547 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY; 1548 1549 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) 1550 audio_size += data_size; 1551 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) { 1552 video_size += data_size; 1553 ost->sync_opts++; 1554 } 1555 1556 opkt.stream_index= ost->index; 1557 if(pkt->pts != AV_NOPTS_VALUE) 1558 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time; 1559 else 1560 opkt.pts= AV_NOPTS_VALUE; 1561 1562 if (pkt->dts == AV_NOPTS_VALUE) 1563 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base); 1564 else 1565 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base); 1566 opkt.dts -= ost_tb_start_time; 1567 1568 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base); 1569 opkt.flags= pkt->flags; 1570 1571 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters 1572 if( ost->st->codec->codec_id != CODEC_ID_H264 1573 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO 1574 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO 1575 ) { 1576 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY)) 1577 opkt.destruct= av_destruct_packet; 1578 } else { 1579 opkt.data = data_buf; 1580 opkt.size = data_size; 1581 } 1582 1583 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]); 1584 ost->st->codec->frame_number++; 1585 ost->frame_number++; 1586 av_free_packet(&opkt); 1587 } 1588 } 1589 } 1590 av_free(buffer_to_free); 1591 /* XXX: allocate the subtitles in the codec ? */ 1592 if (subtitle_to_free) { 1593 if (subtitle_to_free->rects != NULL) { 1594 for (i = 0; i < subtitle_to_free->num_rects; i++) { 1595 av_freep(&subtitle_to_free->rects[i]->pict.data[0]); 1596 av_freep(&subtitle_to_free->rects[i]->pict.data[1]); 1597 av_freep(&subtitle_to_free->rects[i]); 1598 } 1599 av_freep(&subtitle_to_free->rects); 1600 } 1601 subtitle_to_free->num_rects = 0; 1602 subtitle_to_free = NULL; 1603 } 1604 } 1605 discard_packet: 1606 if (pkt == NULL) { 1607 /* EOF handling */ 1608 1609 for(i=0;i<nb_ostreams;i++) { 1610 ost = ost_table[i]; 1611 if (ost->source_index == ist_index) { 1612 AVCodecContext *enc= ost->st->codec; 1613 os = output_files[ost->file_index]; 1614 1615 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1) 1616 continue; 1617 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE)) 1618 continue; 1619 1620 if (ost->encoding_needed) { 1621 for(;;) { 1622 AVPacket pkt; 1623 int fifo_bytes; 1624 av_init_packet(&pkt); 1625 pkt.stream_index= ost->index; 1626 1627 switch(ost->st->codec->codec_type) { 1628 case AVMEDIA_TYPE_AUDIO: 1629 fifo_bytes = av_fifo_size(ost->fifo); 1630 ret = 0; 1631 /* encode any samples remaining in fifo */ 1632 if (fifo_bytes > 0) { 1633 int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3; 1634 int fs_tmp = enc->frame_size; 1635 1636 av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL); 1637 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) { 1638 enc->frame_size = fifo_bytes / (osize * enc->channels); 1639 } else { /* pad */ 1640 int frame_bytes = enc->frame_size*osize*enc->channels; 1641 if (samples_size < frame_bytes) 1642 av_exit(1); 1643 memset((uint8_t*)samples+fifo_bytes, 0, frame_bytes - fifo_bytes); 1644 } 1645 1646 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples); 1647 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den, 1648 ost->st->time_base.num, enc->sample_rate); 1649 enc->frame_size = fs_tmp; 1650 } 1651 if(ret <= 0) { 1652 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL); 1653 } 1654 if (ret < 0) { 1655 fprintf(stderr, "Audio encoding failed\n"); 1656 av_exit(1); 1657 } 1658 audio_size += ret; 1659 pkt.flags |= AV_PKT_FLAG_KEY; 1660 break; 1661 case AVMEDIA_TYPE_VIDEO: 1662 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL); 1663 if (ret < 0) { 1664 fprintf(stderr, "Video encoding failed\n"); 1665 av_exit(1); 1666 } 1667 video_size += ret; 1668 if(enc->coded_frame && enc->coded_frame->key_frame) 1669 pkt.flags |= AV_PKT_FLAG_KEY; 1670 if (ost->logfile && enc->stats_out) { 1671 fprintf(ost->logfile, "%s", enc->stats_out); 1672 } 1673 break; 1674 default: 1675 ret=-1; 1676 } 1677 1678 if(ret<=0) 1679 break; 1680 pkt.data= bit_buffer; 1681 pkt.size= ret; 1682 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE) 1683 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base); 1684 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]); 1685 } 1686 } 1687 } 1688 } 1689 } 1690 1691 return 0; 1692 fail_decode: 1693 return -1; 1694} 1695 1696static void print_sdp(AVFormatContext **avc, int n) 1697{ 1698 char sdp[2048]; 1699 1700 avf_sdp_create(avc, n, sdp, sizeof(sdp)); 1701 printf("SDP:\n%s\n", sdp); 1702 fflush(stdout); 1703} 1704 1705static int copy_chapters(int infile, int outfile) 1706{ 1707 AVFormatContext *is = input_files[infile]; 1708 AVFormatContext *os = output_files[outfile]; 1709 int i; 1710 1711 for (i = 0; i < is->nb_chapters; i++) { 1712 AVChapter *in_ch = is->chapters[i], *out_ch; 1713 AVMetadataTag *t = NULL; 1714 int64_t ts_off = av_rescale_q(start_time - input_files_ts_offset[infile], 1715 AV_TIME_BASE_Q, in_ch->time_base); 1716 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX : 1717 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base); 1718 1719 1720 if (in_ch->end < ts_off) 1721 continue; 1722 if (rt != INT64_MAX && in_ch->start > rt + ts_off) 1723 break; 1724 1725 out_ch = av_mallocz(sizeof(AVChapter)); 1726 if (!out_ch) 1727 return AVERROR(ENOMEM); 1728 1729 out_ch->id = in_ch->id; 1730 out_ch->time_base = in_ch->time_base; 1731 out_ch->start = FFMAX(0, in_ch->start - ts_off); 1732 out_ch->end = FFMIN(rt, in_ch->end - ts_off); 1733 1734 while ((t = av_metadata_get(in_ch->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) 1735 av_metadata_set2(&out_ch->metadata, t->key, t->value, 0); 1736 1737 os->nb_chapters++; 1738 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters); 1739 if (!os->chapters) 1740 return AVERROR(ENOMEM); 1741 os->chapters[os->nb_chapters - 1] = out_ch; 1742 } 1743 return 0; 1744} 1745 1746/* 1747 * The following code is the main loop of the file converter 1748 */ 1749static int av_transcode(AVFormatContext **output_files, 1750 int nb_output_files, 1751 AVFormatContext **input_files, 1752 int nb_input_files, 1753 AVStreamMap *stream_maps, int nb_stream_maps) 1754{ 1755 int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0; 1756 AVFormatContext *is, *os; 1757 AVCodecContext *codec, *icodec; 1758 AVOutputStream *ost, **ost_table = NULL; 1759 AVInputStream *ist, **ist_table = NULL; 1760 AVInputFile *file_table; 1761 char error[1024]; 1762 int key; 1763 int want_sdp = 1; 1764 uint8_t no_packet[MAX_FILES]={0}; 1765 int no_packet_count=0; 1766 1767 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile)); 1768 if (!file_table) 1769 goto fail; 1770 1771 /* input stream init */ 1772 j = 0; 1773 for(i=0;i<nb_input_files;i++) { 1774 is = input_files[i]; 1775 file_table[i].ist_index = j; 1776 file_table[i].nb_streams = is->nb_streams; 1777 j += is->nb_streams; 1778 } 1779 nb_istreams = j; 1780 1781 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *)); 1782 if (!ist_table) 1783 goto fail; 1784 1785 for(i=0;i<nb_istreams;i++) { 1786 ist = av_mallocz(sizeof(AVInputStream)); 1787 if (!ist) 1788 goto fail; 1789 ist_table[i] = ist; 1790 } 1791 j = 0; 1792 for(i=0;i<nb_input_files;i++) { 1793 is = input_files[i]; 1794 for(k=0;k<is->nb_streams;k++) { 1795 ist = ist_table[j++]; 1796 ist->st = is->streams[k]; 1797 ist->file_index = i; 1798 ist->index = k; 1799 ist->discard = 1; /* the stream is discarded by default 1800 (changed later) */ 1801 1802 if (rate_emu) { 1803 ist->start = av_gettime(); 1804 } 1805 } 1806 } 1807 1808 /* output stream init */ 1809 nb_ostreams = 0; 1810 for(i=0;i<nb_output_files;i++) { 1811 os = output_files[i]; 1812 if (!os->nb_streams) { 1813 dump_format(output_files[i], i, output_files[i]->filename, 1); 1814 fprintf(stderr, "Output file #%d does not contain any stream\n", i); 1815 av_exit(1); 1816 } 1817 nb_ostreams += os->nb_streams; 1818 } 1819 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) { 1820 fprintf(stderr, "Number of stream maps must match number of output streams\n"); 1821 av_exit(1); 1822 } 1823 1824 /* Sanity check the mapping args -- do the input files & streams exist? */ 1825 for(i=0;i<nb_stream_maps;i++) { 1826 int fi = stream_maps[i].file_index; 1827 int si = stream_maps[i].stream_index; 1828 1829 if (fi < 0 || fi > nb_input_files - 1 || 1830 si < 0 || si > file_table[fi].nb_streams - 1) { 1831 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si); 1832 av_exit(1); 1833 } 1834 fi = stream_maps[i].sync_file_index; 1835 si = stream_maps[i].sync_stream_index; 1836 if (fi < 0 || fi > nb_input_files - 1 || 1837 si < 0 || si > file_table[fi].nb_streams - 1) { 1838 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si); 1839 av_exit(1); 1840 } 1841 } 1842 1843 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams); 1844 if (!ost_table) 1845 goto fail; 1846 for(i=0;i<nb_ostreams;i++) { 1847 ost = av_mallocz(sizeof(AVOutputStream)); 1848 if (!ost) 1849 goto fail; 1850 ost_table[i] = ost; 1851 } 1852 1853 n = 0; 1854 for(k=0;k<nb_output_files;k++) { 1855 os = output_files[k]; 1856 for(i=0;i<os->nb_streams;i++,n++) { 1857 int found; 1858 ost = ost_table[n]; 1859 ost->file_index = k; 1860 ost->index = i; 1861 ost->st = os->streams[i]; 1862 if (nb_stream_maps > 0) { 1863 ost->source_index = file_table[stream_maps[n].file_index].ist_index + 1864 stream_maps[n].stream_index; 1865 1866 /* Sanity check that the stream types match */ 1867 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) { 1868 int i= ost->file_index; 1869 dump_format(output_files[i], i, output_files[i]->filename, 1); 1870 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n", 1871 stream_maps[n].file_index, stream_maps[n].stream_index, 1872 ost->file_index, ost->index); 1873 av_exit(1); 1874 } 1875 1876 } else { 1877 int best_nb_frames=-1; 1878 /* get corresponding input stream index : we select the first one with the right type */ 1879 found = 0; 1880 for(j=0;j<nb_istreams;j++) { 1881 int skip=0; 1882 ist = ist_table[j]; 1883 if(opt_programid){ 1884 int pi,si; 1885 AVFormatContext *f= input_files[ ist->file_index ]; 1886 skip=1; 1887 for(pi=0; pi<f->nb_programs; pi++){ 1888 AVProgram *p= f->programs[pi]; 1889 if(p->id == opt_programid) 1890 for(si=0; si<p->nb_stream_indexes; si++){ 1891 if(f->streams[ p->stream_index[si] ] == ist->st) 1892 skip=0; 1893 } 1894 } 1895 } 1896 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip && 1897 ist->st->codec->codec_type == ost->st->codec->codec_type) { 1898 if(best_nb_frames < ist->st->codec_info_nb_frames){ 1899 best_nb_frames= ist->st->codec_info_nb_frames; 1900 ost->source_index = j; 1901 found = 1; 1902 } 1903 } 1904 } 1905 1906 if (!found) { 1907 if(! opt_programid) { 1908 /* try again and reuse existing stream */ 1909 for(j=0;j<nb_istreams;j++) { 1910 ist = ist_table[j]; 1911 if ( ist->st->codec->codec_type == ost->st->codec->codec_type 1912 && ist->st->discard != AVDISCARD_ALL) { 1913 ost->source_index = j; 1914 found = 1; 1915 } 1916 } 1917 } 1918 if (!found) { 1919 int i= ost->file_index; 1920 dump_format(output_files[i], i, output_files[i]->filename, 1); 1921 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n", 1922 ost->file_index, ost->index); 1923 av_exit(1); 1924 } 1925 } 1926 } 1927 ist = ist_table[ost->source_index]; 1928 ist->discard = 0; 1929 ost->sync_ist = (nb_stream_maps > 0) ? 1930 ist_table[file_table[stream_maps[n].sync_file_index].ist_index + 1931 stream_maps[n].sync_stream_index] : ist; 1932 } 1933 } 1934 1935 /* for each output stream, we compute the right encoding parameters */ 1936 for(i=0;i<nb_ostreams;i++) { 1937 AVMetadataTag *t = NULL; 1938 ost = ost_table[i]; 1939 os = output_files[ost->file_index]; 1940 ist = ist_table[ost->source_index]; 1941 1942 codec = ost->st->codec; 1943 icodec = ist->st->codec; 1944 1945 while ((t = av_metadata_get(ist->st->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) { 1946 av_metadata_set2(&ost->st->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE); 1947 } 1948 1949 ost->st->disposition = ist->st->disposition; 1950 codec->bits_per_raw_sample= icodec->bits_per_raw_sample; 1951 codec->chroma_sample_location = icodec->chroma_sample_location; 1952 1953 if (ost->st->stream_copy) { 1954 /* if stream_copy is selected, no need to decode or encode */ 1955 codec->codec_id = icodec->codec_id; 1956 codec->codec_type = icodec->codec_type; 1957 1958 if(!codec->codec_tag){ 1959 if( !os->oformat->codec_tag 1960 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id 1961 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0) 1962 codec->codec_tag = icodec->codec_tag; 1963 } 1964 1965 codec->bit_rate = icodec->bit_rate; 1966 codec->extradata= icodec->extradata; 1967 codec->extradata_size= icodec->extradata_size; 1968 if(av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000){ 1969 codec->time_base = icodec->time_base; 1970 codec->time_base.num *= icodec->ticks_per_frame; 1971 }else 1972 codec->time_base = ist->st->time_base; 1973 switch(codec->codec_type) { 1974 case AVMEDIA_TYPE_AUDIO: 1975 if(audio_volume != 256) { 1976 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n"); 1977 av_exit(1); 1978 } 1979 codec->channel_layout = icodec->channel_layout; 1980 codec->sample_rate = icodec->sample_rate; 1981 codec->channels = icodec->channels; 1982 codec->frame_size = icodec->frame_size; 1983 codec->block_align= icodec->block_align; 1984 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3) 1985 codec->block_align= 0; 1986 if(codec->codec_id == CODEC_ID_AC3) 1987 codec->block_align= 0; 1988 break; 1989 case AVMEDIA_TYPE_VIDEO: 1990 codec->pix_fmt = icodec->pix_fmt; 1991 codec->width = icodec->width; 1992 codec->height = icodec->height; 1993 codec->has_b_frames = icodec->has_b_frames; 1994 break; 1995 case AVMEDIA_TYPE_SUBTITLE: 1996 codec->width = icodec->width; 1997 codec->height = icodec->height; 1998 break; 1999 default: 2000 abort(); 2001 } 2002 } else { 2003 switch(codec->codec_type) { 2004 case AVMEDIA_TYPE_AUDIO: 2005 ost->fifo= av_fifo_alloc(1024); 2006 if(!ost->fifo) 2007 goto fail; 2008 ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE); 2009 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1; 2010 icodec->request_channels = codec->channels; 2011 ist->decoding_needed = 1; 2012 ost->encoding_needed = 1; 2013 break; 2014 case AVMEDIA_TYPE_VIDEO: 2015 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) { 2016 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n"); 2017 av_exit(1); 2018 } 2019 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0); 2020 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0); 2021 ost->video_resample = ((codec->width != icodec->width - 2022 (frame_leftBand + frame_rightBand) + 2023 (frame_padleft + frame_padright)) || 2024 (codec->height != icodec->height - 2025 (frame_topBand + frame_bottomBand) + 2026 (frame_padtop + frame_padbottom)) || 2027 (codec->pix_fmt != icodec->pix_fmt)); 2028 if (ost->video_crop) { 2029 ost->topBand = ost->original_topBand = frame_topBand; 2030 ost->bottomBand = ost->original_bottomBand = frame_bottomBand; 2031 ost->leftBand = ost->original_leftBand = frame_leftBand; 2032 ost->rightBand = ost->original_rightBand = frame_rightBand; 2033 } 2034 if (ost->video_pad) { 2035 ost->padtop = frame_padtop; 2036 ost->padleft = frame_padleft; 2037 ost->padbottom = frame_padbottom; 2038 ost->padright = frame_padright; 2039 if (!ost->video_resample) { 2040 avcodec_get_frame_defaults(&ost->pict_tmp); 2041 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt, 2042 codec->width, codec->height)) 2043 goto fail; 2044 } 2045 } 2046 if (ost->video_resample) { 2047 avcodec_get_frame_defaults(&ost->pict_tmp); 2048 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt, 2049 codec->width, codec->height)) { 2050 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n"); 2051 av_exit(1); 2052 } 2053 sws_flags = av_get_int(sws_opts, "sws_flags", NULL); 2054 ost->img_resample_ctx = sws_getContext( 2055 icodec->width - (frame_leftBand + frame_rightBand), 2056 icodec->height - (frame_topBand + frame_bottomBand), 2057 icodec->pix_fmt, 2058 codec->width - (frame_padleft + frame_padright), 2059 codec->height - (frame_padtop + frame_padbottom), 2060 codec->pix_fmt, 2061 sws_flags, NULL, NULL, NULL); 2062 if (ost->img_resample_ctx == NULL) { 2063 fprintf(stderr, "Cannot get resampling context\n"); 2064 av_exit(1); 2065 } 2066 2067 ost->original_height = icodec->height; 2068 ost->original_width = icodec->width; 2069 2070 codec->bits_per_raw_sample= 0; 2071 } 2072 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand); 2073 ost->resample_width = icodec->width - (frame_leftBand + frame_rightBand); 2074 ost->resample_pix_fmt= icodec->pix_fmt; 2075 ost->encoding_needed = 1; 2076 ist->decoding_needed = 1; 2077 break; 2078 case AVMEDIA_TYPE_SUBTITLE: 2079 ost->encoding_needed = 1; 2080 ist->decoding_needed = 1; 2081 break; 2082 default: 2083 abort(); 2084 break; 2085 } 2086 /* two pass mode */ 2087 if (ost->encoding_needed && 2088 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) { 2089 char logfilename[1024]; 2090 FILE *f; 2091 2092 snprintf(logfilename, sizeof(logfilename), "%s-%d.log", 2093 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX, 2094 i); 2095 if (codec->flags & CODEC_FLAG_PASS1) { 2096 f = fopen(logfilename, "wb"); 2097 if (!f) { 2098 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno)); 2099 av_exit(1); 2100 } 2101 ost->logfile = f; 2102 } else { 2103 char *logbuffer; 2104 size_t logbuffer_size; 2105 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) { 2106 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename); 2107 av_exit(1); 2108 } 2109 codec->stats_in = logbuffer; 2110 } 2111 } 2112 } 2113 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){ 2114 int size= codec->width * codec->height; 2115 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200); 2116 } 2117 } 2118 2119 if (!bit_buffer) 2120 bit_buffer = av_malloc(bit_buffer_size); 2121 if (!bit_buffer) { 2122 fprintf(stderr, "Cannot allocate %d bytes output buffer\n", 2123 bit_buffer_size); 2124 ret = AVERROR(ENOMEM); 2125 goto fail; 2126 } 2127 2128 /* open each encoder */ 2129 for(i=0;i<nb_ostreams;i++) { 2130 ost = ost_table[i]; 2131 if (ost->encoding_needed) { 2132 AVCodec *codec = output_codecs[i]; 2133 if (!codec) 2134 codec = avcodec_find_encoder(ost->st->codec->codec_id); 2135 if (!codec) { 2136 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d", 2137 ost->st->codec->codec_id, ost->file_index, ost->index); 2138 ret = AVERROR(EINVAL); 2139 goto dump_format; 2140 } 2141 if (avcodec_open(ost->st->codec, codec) < 0) { 2142 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height", 2143 ost->file_index, ost->index); 2144 ret = AVERROR(EINVAL); 2145 goto dump_format; 2146 } 2147 extra_size += ost->st->codec->extradata_size; 2148 } 2149 } 2150 2151 /* open each decoder */ 2152 for(i=0;i<nb_istreams;i++) { 2153 ist = ist_table[i]; 2154 if (ist->decoding_needed) { 2155 AVCodec *codec = input_codecs[i]; 2156 if (!codec) 2157 codec = avcodec_find_decoder(ist->st->codec->codec_id); 2158 if (!codec) { 2159 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d", 2160 ist->st->codec->codec_id, ist->file_index, ist->index); 2161 ret = AVERROR(EINVAL); 2162 goto dump_format; 2163 } 2164 if (avcodec_open(ist->st->codec, codec) < 0) { 2165 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d", 2166 ist->file_index, ist->index); 2167 ret = AVERROR(EINVAL); 2168 goto dump_format; 2169 } 2170 //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) 2171 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD; 2172 } 2173 } 2174 2175 /* init pts */ 2176 for(i=0;i<nb_istreams;i++) { 2177 AVStream *st; 2178 ist = ist_table[i]; 2179 st= ist->st; 2180 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0; 2181 ist->next_pts = AV_NOPTS_VALUE; 2182 ist->is_start = 1; 2183 } 2184 2185 /* set meta data information from input file if required */ 2186 for (i=0;i<nb_meta_data_maps;i++) { 2187 AVFormatContext *out_file; 2188 AVFormatContext *in_file; 2189 AVMetadataTag *mtag; 2190 2191 int out_file_index = meta_data_maps[i].out_file; 2192 int in_file_index = meta_data_maps[i].in_file; 2193 if (out_file_index < 0 || out_file_index >= nb_output_files) { 2194 snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)", 2195 out_file_index, out_file_index, in_file_index); 2196 ret = AVERROR(EINVAL); 2197 goto dump_format; 2198 } 2199 if (in_file_index < 0 || in_file_index >= nb_input_files) { 2200 snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)", 2201 in_file_index, out_file_index, in_file_index); 2202 ret = AVERROR(EINVAL); 2203 goto dump_format; 2204 } 2205 2206 out_file = output_files[out_file_index]; 2207 in_file = input_files[in_file_index]; 2208 2209 2210 mtag=NULL; 2211 while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX))) 2212 av_metadata_set2(&out_file->metadata, mtag->key, mtag->value, AV_METADATA_DONT_OVERWRITE); 2213 av_metadata_conv(out_file, out_file->oformat->metadata_conv, 2214 in_file->iformat->metadata_conv); 2215 } 2216 2217 /* copy chapters from the first input file that has them*/ 2218 for (i = 0; i < nb_input_files; i++) { 2219 if (!input_files[i]->nb_chapters) 2220 continue; 2221 2222 for (j = 0; j < nb_output_files; j++) 2223 if ((ret = copy_chapters(i, j)) < 0) 2224 goto dump_format; 2225 } 2226 2227 /* open files and write file headers */ 2228 for(i=0;i<nb_output_files;i++) { 2229 os = output_files[i]; 2230 if (av_write_header(os) < 0) { 2231 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i); 2232 ret = AVERROR(EINVAL); 2233 goto dump_format; 2234 } 2235 if (strcmp(output_files[i]->oformat->name, "rtp")) { 2236 want_sdp = 0; 2237 } 2238 } 2239 2240 dump_format: 2241 /* dump the file output parameters - cannot be done before in case 2242 of stream copy */ 2243 for(i=0;i<nb_output_files;i++) { 2244 dump_format(output_files[i], i, output_files[i]->filename, 1); 2245 } 2246 2247 /* dump the stream mapping */ 2248 if (verbose >= 0) { 2249 fprintf(stderr, "Stream mapping:\n"); 2250 for(i=0;i<nb_ostreams;i++) { 2251 ost = ost_table[i]; 2252 fprintf(stderr, " Stream #%d.%d -> #%d.%d", 2253 ist_table[ost->source_index]->file_index, 2254 ist_table[ost->source_index]->index, 2255 ost->file_index, 2256 ost->index); 2257 if (ost->sync_ist != ist_table[ost->source_index]) 2258 fprintf(stderr, " [sync #%d.%d]", 2259 ost->sync_ist->file_index, 2260 ost->sync_ist->index); 2261 fprintf(stderr, "\n"); 2262 } 2263 } 2264 2265 if (ret) { 2266 fprintf(stderr, "%s\n", error); 2267 goto fail; 2268 } 2269 2270 if (want_sdp) { 2271 print_sdp(output_files, nb_output_files); 2272 } 2273 2274 if (!using_stdin && verbose >= 0) { 2275 fprintf(stderr, "Press [q] to stop encoding\n"); 2276 url_set_interrupt_cb(decode_interrupt_cb); 2277 } 2278 term_init(); 2279 2280 timer_start = av_gettime(); 2281 2282 for(; received_sigterm == 0;) { 2283 int file_index, ist_index; 2284 AVPacket pkt; 2285 double ipts_min; 2286 double opts_min; 2287 2288 redo: 2289 ipts_min= 1e100; 2290 opts_min= 1e100; 2291 /* if 'q' pressed, exits */ 2292 if (!using_stdin) { 2293 if (q_pressed) 2294 break; 2295 /* read_key() returns 0 on EOF */ 2296 key = read_key(); 2297 if (key == 'q') 2298 break; 2299 } 2300 2301 /* select the stream that we must read now by looking at the 2302 smallest output pts */ 2303 file_index = -1; 2304 for(i=0;i<nb_ostreams;i++) { 2305 double ipts, opts; 2306 ost = ost_table[i]; 2307 os = output_files[ost->file_index]; 2308 ist = ist_table[ost->source_index]; 2309 if(ist->is_past_recording_time || no_packet[ist->file_index]) 2310 continue; 2311 opts = ost->st->pts.val * av_q2d(ost->st->time_base); 2312 ipts = (double)ist->pts; 2313 if (!file_table[ist->file_index].eof_reached){ 2314 if(ipts < ipts_min) { 2315 ipts_min = ipts; 2316 if(input_sync ) file_index = ist->file_index; 2317 } 2318 if(opts < opts_min) { 2319 opts_min = opts; 2320 if(!input_sync) file_index = ist->file_index; 2321 } 2322 } 2323 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){ 2324 file_index= -1; 2325 break; 2326 } 2327 } 2328 /* if none, if is finished */ 2329 if (file_index < 0) { 2330 if(no_packet_count){ 2331 no_packet_count=0; 2332 memset(no_packet, 0, sizeof(no_packet)); 2333 usleep(10000); 2334 continue; 2335 } 2336 break; 2337 } 2338 2339 /* finish if limit size exhausted */ 2340 if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb)) 2341 break; 2342 2343 /* read a frame from it and output it in the fifo */ 2344 is = input_files[file_index]; 2345 ret= av_read_frame(is, &pkt); 2346 if(ret == AVERROR(EAGAIN)){ 2347 no_packet[file_index]=1; 2348 no_packet_count++; 2349 continue; 2350 } 2351 if (ret < 0) { 2352 file_table[file_index].eof_reached = 1; 2353 if (opt_shortest) 2354 break; 2355 else 2356 continue; 2357 } 2358 2359 no_packet_count=0; 2360 memset(no_packet, 0, sizeof(no_packet)); 2361 2362 if (do_pkt_dump) { 2363 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump); 2364 } 2365 /* the following test is needed in case new streams appear 2366 dynamically in stream : we ignore them */ 2367 if (pkt.stream_index >= file_table[file_index].nb_streams) 2368 goto discard_packet; 2369 ist_index = file_table[file_index].ist_index + pkt.stream_index; 2370 ist = ist_table[ist_index]; 2371 if (ist->discard) 2372 goto discard_packet; 2373 2374 if (pkt.dts != AV_NOPTS_VALUE) 2375 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base); 2376 if (pkt.pts != AV_NOPTS_VALUE) 2377 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base); 2378 2379 if(input_files_ts_scale[file_index][pkt.stream_index]){ 2380 if(pkt.pts != AV_NOPTS_VALUE) 2381 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index]; 2382 if(pkt.dts != AV_NOPTS_VALUE) 2383 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index]; 2384 } 2385 2386// fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type); 2387 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE 2388 && (is->iformat->flags & AVFMT_TS_DISCONT)) { 2389 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q); 2390 int64_t delta= pkt_dts - ist->next_pts; 2391 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){ 2392 input_files_ts_offset[ist->file_index]-= delta; 2393 if (verbose > 2) 2394 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]); 2395 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base); 2396 if(pkt.pts != AV_NOPTS_VALUE) 2397 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base); 2398 } 2399 } 2400 2401 /* finish if recording time exhausted */ 2402 if (recording_time != INT64_MAX && 2403 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) { 2404 ist->is_past_recording_time = 1; 2405 goto discard_packet; 2406 } 2407 2408 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size); 2409 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) { 2410 2411 if (verbose >= 0) 2412 fprintf(stderr, "Error while decoding stream #%d.%d\n", 2413 ist->file_index, ist->index); 2414 if (exit_on_error) 2415 av_exit(1); 2416 av_free_packet(&pkt); 2417 goto redo; 2418 } 2419 2420 discard_packet: 2421 av_free_packet(&pkt); 2422 2423 /* dump report by using the output first video and audio streams */ 2424 print_report(output_files, ost_table, nb_ostreams, 0); 2425 } 2426 2427 /* at the end of stream, we must flush the decoder buffers */ 2428 for(i=0;i<nb_istreams;i++) { 2429 ist = ist_table[i]; 2430 if (ist->decoding_needed) { 2431 output_packet(ist, i, ost_table, nb_ostreams, NULL); 2432 } 2433 } 2434 2435 term_exit(); 2436 2437 /* write the trailer if needed and close file */ 2438 for(i=0;i<nb_output_files;i++) { 2439 os = output_files[i]; 2440 av_write_trailer(os); 2441 } 2442 2443 /* dump report by using the first video and audio streams */ 2444 print_report(output_files, ost_table, nb_ostreams, 1); 2445 2446 /* close each encoder */ 2447 for(i=0;i<nb_ostreams;i++) { 2448 ost = ost_table[i]; 2449 if (ost->encoding_needed) { 2450 av_freep(&ost->st->codec->stats_in); 2451 avcodec_close(ost->st->codec); 2452 } 2453 } 2454 2455 /* close each decoder */ 2456 for(i=0;i<nb_istreams;i++) { 2457 ist = ist_table[i]; 2458 if (ist->decoding_needed) { 2459 avcodec_close(ist->st->codec); 2460 } 2461 } 2462 2463 /* finished ! */ 2464 ret = 0; 2465 2466 fail: 2467 av_freep(&bit_buffer); 2468 av_free(file_table); 2469 2470 if (ist_table) { 2471 for(i=0;i<nb_istreams;i++) { 2472 ist = ist_table[i]; 2473 av_free(ist); 2474 } 2475 av_free(ist_table); 2476 } 2477 if (ost_table) { 2478 for(i=0;i<nb_ostreams;i++) { 2479 ost = ost_table[i]; 2480 if (ost) { 2481 if (ost->logfile) { 2482 fclose(ost->logfile); 2483 ost->logfile = NULL; 2484 } 2485 av_fifo_free(ost->fifo); /* works even if fifo is not 2486 initialized but set to zero */ 2487 av_free(ost->pict_tmp.data[0]); 2488 if (ost->video_resample) 2489 sws_freeContext(ost->img_resample_ctx); 2490 if (ost->resample) 2491 audio_resample_close(ost->resample); 2492 if (ost->reformat_ctx) 2493 av_audio_convert_free(ost->reformat_ctx); 2494 av_free(ost); 2495 } 2496 } 2497 av_free(ost_table); 2498 } 2499 return ret; 2500} 2501 2502static void opt_format(const char *arg) 2503{ 2504 /* compatibility stuff for pgmyuv */ 2505 if (!strcmp(arg, "pgmyuv")) { 2506 pgmyuv_compatibility_hack=1; 2507// opt_image_format(arg); 2508 arg = "image2"; 2509 fprintf(stderr, "pgmyuv format is deprecated, use image2\n"); 2510 } 2511 2512 last_asked_format = arg; 2513} 2514 2515static void opt_video_rc_override_string(const char *arg) 2516{ 2517 video_rc_override_string = arg; 2518} 2519 2520static int opt_me_threshold(const char *opt, const char *arg) 2521{ 2522 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX); 2523 return 0; 2524} 2525 2526static int opt_verbose(const char *opt, const char *arg) 2527{ 2528 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10); 2529 return 0; 2530} 2531 2532static int opt_frame_rate(const char *opt, const char *arg) 2533{ 2534 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) { 2535 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg); 2536 av_exit(1); 2537 } 2538 return 0; 2539} 2540 2541static int opt_bitrate(const char *opt, const char *arg) 2542{ 2543 int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO; 2544 2545 opt_default(opt, arg); 2546 2547 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000) 2548 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n"); 2549 2550 return 0; 2551} 2552 2553static void opt_frame_crop_top(const char *arg) 2554{ 2555 frame_topBand = atoi(arg); 2556 if (frame_topBand < 0) { 2557 fprintf(stderr, "Incorrect top crop size\n"); 2558 av_exit(1); 2559 } 2560 if ((frame_topBand) >= frame_height){ 2561 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n"); 2562 av_exit(1); 2563 } 2564 frame_height -= frame_topBand; 2565} 2566 2567static void opt_frame_crop_bottom(const char *arg) 2568{ 2569 frame_bottomBand = atoi(arg); 2570 if (frame_bottomBand < 0) { 2571 fprintf(stderr, "Incorrect bottom crop size\n"); 2572 av_exit(1); 2573 } 2574 if ((frame_bottomBand) >= frame_height){ 2575 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n"); 2576 av_exit(1); 2577 } 2578 frame_height -= frame_bottomBand; 2579} 2580 2581static void opt_frame_crop_left(const char *arg) 2582{ 2583 frame_leftBand = atoi(arg); 2584 if (frame_leftBand < 0) { 2585 fprintf(stderr, "Incorrect left crop size\n"); 2586 av_exit(1); 2587 } 2588 if ((frame_leftBand) >= frame_width){ 2589 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n"); 2590 av_exit(1); 2591 } 2592 frame_width -= frame_leftBand; 2593} 2594 2595static void opt_frame_crop_right(const char *arg) 2596{ 2597 frame_rightBand = atoi(arg); 2598 if (frame_rightBand < 0) { 2599 fprintf(stderr, "Incorrect right crop size\n"); 2600 av_exit(1); 2601 } 2602 if ((frame_rightBand) >= frame_width){ 2603 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n"); 2604 av_exit(1); 2605 } 2606 frame_width -= frame_rightBand; 2607} 2608 2609static void opt_frame_size(const char *arg) 2610{ 2611 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) { 2612 fprintf(stderr, "Incorrect frame size\n"); 2613 av_exit(1); 2614 } 2615} 2616 2617static void opt_pad_color(const char *arg) { 2618 /* Input is expected to be six hex digits similar to 2619 how colors are expressed in html tags (but without the #) */ 2620 int rgb = strtol(arg, NULL, 16); 2621 int r,g,b; 2622 2623 r = (rgb >> 16); 2624 g = ((rgb >> 8) & 255); 2625 b = (rgb & 255); 2626 2627 padcolor[0] = RGB_TO_Y(r,g,b); 2628 padcolor[1] = RGB_TO_U(r,g,b,0); 2629 padcolor[2] = RGB_TO_V(r,g,b,0); 2630} 2631 2632static void opt_frame_pad_top(const char *arg) 2633{ 2634 frame_padtop = atoi(arg); 2635 if (frame_padtop < 0) { 2636 fprintf(stderr, "Incorrect top pad size\n"); 2637 av_exit(1); 2638 } 2639} 2640 2641static void opt_frame_pad_bottom(const char *arg) 2642{ 2643 frame_padbottom = atoi(arg); 2644 if (frame_padbottom < 0) { 2645 fprintf(stderr, "Incorrect bottom pad size\n"); 2646 av_exit(1); 2647 } 2648} 2649 2650 2651static void opt_frame_pad_left(const char *arg) 2652{ 2653 frame_padleft = atoi(arg); 2654 if (frame_padleft < 0) { 2655 fprintf(stderr, "Incorrect left pad size\n"); 2656 av_exit(1); 2657 } 2658} 2659 2660 2661static void opt_frame_pad_right(const char *arg) 2662{ 2663 frame_padright = atoi(arg); 2664 if (frame_padright < 0) { 2665 fprintf(stderr, "Incorrect right pad size\n"); 2666 av_exit(1); 2667 } 2668} 2669 2670static void opt_frame_pix_fmt(const char *arg) 2671{ 2672 if (strcmp(arg, "list")) { 2673 frame_pix_fmt = av_get_pix_fmt(arg); 2674 if (frame_pix_fmt == PIX_FMT_NONE) { 2675 fprintf(stderr, "Unknown pixel format requested: %s\n", arg); 2676 av_exit(1); 2677 } 2678 } else { 2679 show_pix_fmts(); 2680 av_exit(0); 2681 } 2682} 2683 2684static void opt_frame_aspect_ratio(const char *arg) 2685{ 2686 int x = 0, y = 0; 2687 double ar = 0; 2688 const char *p; 2689 char *end; 2690 2691 p = strchr(arg, ':'); 2692 if (p) { 2693 x = strtol(arg, &end, 10); 2694 if (end == p) 2695 y = strtol(end+1, &end, 10); 2696 if (x > 0 && y > 0) 2697 ar = (double)x / (double)y; 2698 } else 2699 ar = strtod(arg, NULL); 2700 2701 if (!ar) { 2702 fprintf(stderr, "Incorrect aspect ratio specification.\n"); 2703 av_exit(1); 2704 } 2705 frame_aspect_ratio = ar; 2706} 2707 2708static int opt_metadata(const char *opt, const char *arg) 2709{ 2710 char *mid= strchr(arg, '='); 2711 2712 if(!mid){ 2713 fprintf(stderr, "Missing =\n"); 2714 av_exit(1); 2715 } 2716 *mid++= 0; 2717 2718 metadata_count++; 2719 metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count); 2720 metadata[metadata_count-1].key = av_strdup(arg); 2721 metadata[metadata_count-1].value= av_strdup(mid); 2722 2723 return 0; 2724} 2725 2726static void opt_qscale(const char *arg) 2727{ 2728 video_qscale = atof(arg); 2729 if (video_qscale <= 0 || 2730 video_qscale > 255) { 2731 fprintf(stderr, "qscale must be > 0.0 and <= 255\n"); 2732 av_exit(1); 2733 } 2734} 2735 2736static void opt_top_field_first(const char *arg) 2737{ 2738 top_field_first= atoi(arg); 2739} 2740 2741static int opt_thread_count(const char *opt, const char *arg) 2742{ 2743 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX); 2744#if !HAVE_THREADS 2745 if (verbose >= 0) 2746 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n"); 2747#endif 2748 return 0; 2749} 2750 2751static void opt_audio_sample_fmt(const char *arg) 2752{ 2753 if (strcmp(arg, "list")) 2754 audio_sample_fmt = avcodec_get_sample_fmt(arg); 2755 else { 2756 list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB); 2757 av_exit(0); 2758 } 2759} 2760 2761static int opt_audio_rate(const char *opt, const char *arg) 2762{ 2763 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX); 2764 return 0; 2765} 2766 2767static int opt_audio_channels(const char *opt, const char *arg) 2768{ 2769 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX); 2770 return 0; 2771} 2772 2773static void opt_video_channel(const char *arg) 2774{ 2775 video_channel = strtol(arg, NULL, 0); 2776} 2777 2778static void opt_video_standard(const char *arg) 2779{ 2780 video_standard = av_strdup(arg); 2781} 2782 2783static void opt_codec(int *pstream_copy, char **pcodec_name, 2784 int codec_type, const char *arg) 2785{ 2786 av_freep(pcodec_name); 2787 if (!strcmp(arg, "copy")) { 2788 *pstream_copy = 1; 2789 } else { 2790 *pcodec_name = av_strdup(arg); 2791 } 2792} 2793 2794static void opt_audio_codec(const char *arg) 2795{ 2796 opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg); 2797} 2798 2799static void opt_audio_tag(const char *arg) 2800{ 2801 char *tail; 2802 audio_codec_tag= strtol(arg, &tail, 0); 2803 2804 if(!tail || *tail) 2805 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24); 2806} 2807 2808static void opt_video_tag(const char *arg) 2809{ 2810 char *tail; 2811 video_codec_tag= strtol(arg, &tail, 0); 2812 2813 if(!tail || *tail) 2814 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24); 2815} 2816 2817static void opt_video_codec(const char *arg) 2818{ 2819 opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg); 2820} 2821 2822static void opt_subtitle_codec(const char *arg) 2823{ 2824 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg); 2825} 2826 2827static void opt_subtitle_tag(const char *arg) 2828{ 2829 char *tail; 2830 subtitle_codec_tag= strtol(arg, &tail, 0); 2831 2832 if(!tail || *tail) 2833 subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24); 2834} 2835 2836static void opt_map(const char *arg) 2837{ 2838 AVStreamMap *m; 2839 char *p; 2840 2841 m = &stream_maps[nb_stream_maps++]; 2842 2843 m->file_index = strtol(arg, &p, 0); 2844 if (*p) 2845 p++; 2846 2847 m->stream_index = strtol(p, &p, 0); 2848 if (*p) { 2849 p++; 2850 m->sync_file_index = strtol(p, &p, 0); 2851 if (*p) 2852 p++; 2853 m->sync_stream_index = strtol(p, &p, 0); 2854 } else { 2855 m->sync_file_index = m->file_index; 2856 m->sync_stream_index = m->stream_index; 2857 } 2858} 2859 2860static void opt_map_meta_data(const char *arg) 2861{ 2862 AVMetaDataMap *m; 2863 char *p; 2864 2865 m = &meta_data_maps[nb_meta_data_maps++]; 2866 2867 m->out_file = strtol(arg, &p, 0); 2868 if (*p) 2869 p++; 2870 2871 m->in_file = strtol(p, &p, 0); 2872} 2873 2874static void opt_input_ts_scale(const char *arg) 2875{ 2876 unsigned int stream; 2877 double scale; 2878 char *p; 2879 2880 stream = strtol(arg, &p, 0); 2881 if (*p) 2882 p++; 2883 scale= strtod(p, &p); 2884 2885 if(stream >= MAX_STREAMS) 2886 av_exit(1); 2887 2888 input_files_ts_scale[nb_input_files][stream]= scale; 2889} 2890 2891static int opt_recording_time(const char *opt, const char *arg) 2892{ 2893 recording_time = parse_time_or_die(opt, arg, 1); 2894 return 0; 2895} 2896 2897static int opt_start_time(const char *opt, const char *arg) 2898{ 2899 start_time = parse_time_or_die(opt, arg, 1); 2900 return 0; 2901} 2902 2903static int opt_rec_timestamp(const char *opt, const char *arg) 2904{ 2905 rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000; 2906 return 0; 2907} 2908 2909static int opt_input_ts_offset(const char *opt, const char *arg) 2910{ 2911 input_ts_offset = parse_time_or_die(opt, arg, 1); 2912 return 0; 2913} 2914 2915static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict) 2916{ 2917 const char *codec_string = encoder ? "encoder" : "decoder"; 2918 AVCodec *codec; 2919 2920 if(!name) 2921 return CODEC_ID_NONE; 2922 codec = encoder ? 2923 avcodec_find_encoder_by_name(name) : 2924 avcodec_find_decoder_by_name(name); 2925 if(!codec) { 2926 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name); 2927 av_exit(1); 2928 } 2929 if(codec->type != type) { 2930 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name); 2931 av_exit(1); 2932 } 2933 if(codec->capabilities & CODEC_CAP_EXPERIMENTAL && 2934 strict > FF_COMPLIANCE_EXPERIMENTAL) { 2935 fprintf(stderr, "%s '%s' is experimental and might produce bad " 2936 "results.\nAdd '-strict experimental' if you want to use it.\n", 2937 codec_string, codec->name); 2938 codec = encoder ? 2939 avcodec_find_encoder(codec->id) : 2940 avcodec_find_decoder(codec->id); 2941 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL)) 2942 fprintf(stderr, "Or use the non experimental %s '%s'.\n", 2943 codec_string, codec->name); 2944 av_exit(1); 2945 } 2946 return codec->id; 2947} 2948 2949static void opt_input_file(const char *filename) 2950{ 2951 AVFormatContext *ic; 2952 AVFormatParameters params, *ap = ¶ms; 2953 AVInputFormat *file_iformat = NULL; 2954 int err, i, ret, rfps, rfps_base; 2955 int64_t timestamp; 2956 2957 if (last_asked_format) { 2958 if (!(file_iformat = av_find_input_format(last_asked_format))) { 2959 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format); 2960 av_exit(1); 2961 } 2962 last_asked_format = NULL; 2963 } 2964 2965 if (!strcmp(filename, "-")) 2966 filename = "pipe:"; 2967 2968 using_stdin |= !strncmp(filename, "pipe:", 5) || 2969 !strcmp(filename, "/dev/stdin"); 2970 2971 /* get default parameters from command line */ 2972 ic = avformat_alloc_context(); 2973 if (!ic) { 2974 print_error(filename, AVERROR(ENOMEM)); 2975 av_exit(1); 2976 } 2977 2978 memset(ap, 0, sizeof(*ap)); 2979 ap->prealloced_context = 1; 2980 ap->sample_rate = audio_sample_rate; 2981 ap->channels = audio_channels; 2982 ap->time_base.den = frame_rate.num; 2983 ap->time_base.num = frame_rate.den; 2984 ap->width = frame_width + frame_padleft + frame_padright; 2985 ap->height = frame_height + frame_padtop + frame_padbottom; 2986 ap->pix_fmt = frame_pix_fmt; 2987 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat 2988 ap->channel = video_channel; 2989 ap->standard = video_standard; 2990 2991 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM); 2992 2993 ic->video_codec_id = 2994 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0, 2995 avcodec_opts[AVMEDIA_TYPE_VIDEO ]->strict_std_compliance); 2996 ic->audio_codec_id = 2997 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0, 2998 avcodec_opts[AVMEDIA_TYPE_AUDIO ]->strict_std_compliance); 2999 ic->subtitle_codec_id= 3000 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0, 3001 avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance); 3002 ic->flags |= AVFMT_FLAG_NONBLOCK; 3003 3004 if(pgmyuv_compatibility_hack) 3005 ic->video_codec_id= CODEC_ID_PGMYUV; 3006 3007 /* open the input file with generic libav function */ 3008 err = av_open_input_file(&ic, filename, file_iformat, 0, ap); 3009 if (err < 0) { 3010 print_error(filename, err); 3011 av_exit(1); 3012 } 3013 if(opt_programid) { 3014 int i, j; 3015 int found=0; 3016 for(i=0; i<ic->nb_streams; i++){ 3017 ic->streams[i]->discard= AVDISCARD_ALL; 3018 } 3019 for(i=0; i<ic->nb_programs; i++){ 3020 AVProgram *p= ic->programs[i]; 3021 if(p->id != opt_programid){ 3022 p->discard = AVDISCARD_ALL; 3023 }else{ 3024 found=1; 3025 for(j=0; j<p->nb_stream_indexes; j++){ 3026 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT; 3027 } 3028 } 3029 } 3030 if(!found){ 3031 fprintf(stderr, "Specified program id not found\n"); 3032 av_exit(1); 3033 } 3034 opt_programid=0; 3035 } 3036 3037 ic->loop_input = loop_input; 3038 3039 /* If not enough info to get the stream parameters, we decode the 3040 first frames to get it. (used in mpeg case for example) */ 3041 ret = av_find_stream_info(ic); 3042 if (ret < 0 && verbose >= 0) { 3043 fprintf(stderr, "%s: could not find codec parameters\n", filename); 3044 av_exit(1); 3045 } 3046 3047 timestamp = start_time; 3048 /* add the stream start time */ 3049 if (ic->start_time != AV_NOPTS_VALUE) 3050 timestamp += ic->start_time; 3051 3052 /* if seeking requested, we execute it */ 3053 if (start_time != 0) { 3054 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD); 3055 if (ret < 0) { 3056 fprintf(stderr, "%s: could not seek to position %0.3f\n", 3057 filename, (double)timestamp / AV_TIME_BASE); 3058 } 3059 /* reset seek info */ 3060 start_time = 0; 3061 } 3062 3063 /* update the current parameters so that they match the one of the input stream */ 3064 for(i=0;i<ic->nb_streams;i++) { 3065 AVStream *st = ic->streams[i]; 3066 AVCodecContext *enc = st->codec; 3067 avcodec_thread_init(enc, thread_count); 3068 switch(enc->codec_type) { 3069 case AVMEDIA_TYPE_AUDIO: 3070 set_context_opts(enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM); 3071 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels); 3072 channel_layout = enc->channel_layout; 3073 audio_channels = enc->channels; 3074 audio_sample_rate = enc->sample_rate; 3075 audio_sample_fmt = enc->sample_fmt; 3076 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name); 3077 if(audio_disable) 3078 st->discard= AVDISCARD_ALL; 3079 break; 3080 case AVMEDIA_TYPE_VIDEO: 3081 set_context_opts(enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM); 3082 frame_height = enc->height; 3083 frame_width = enc->width; 3084 if(ic->streams[i]->sample_aspect_ratio.num) 3085 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio); 3086 else 3087 frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio); 3088 frame_aspect_ratio *= (float) enc->width / enc->height; 3089 frame_pix_fmt = enc->pix_fmt; 3090 rfps = ic->streams[i]->r_frame_rate.num; 3091 rfps_base = ic->streams[i]->r_frame_rate.den; 3092 if(enc->lowres) { 3093 enc->flags |= CODEC_FLAG_EMU_EDGE; 3094 frame_height >>= enc->lowres; 3095 frame_width >>= enc->lowres; 3096 } 3097 if(me_threshold) 3098 enc->debug |= FF_DEBUG_MV; 3099 3100 if (enc->time_base.den != rfps*enc->ticks_per_frame || enc->time_base.num != rfps_base) { 3101 3102 if (verbose >= 0) 3103 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n", 3104 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num, 3105 3106 (float)rfps / rfps_base, rfps, rfps_base); 3107 } 3108 /* update the current frame rate to match the stream frame rate */ 3109 frame_rate.num = rfps; 3110 frame_rate.den = rfps_base; 3111 3112 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name); 3113 if(video_disable) 3114 st->discard= AVDISCARD_ALL; 3115 else if(video_discard) 3116 st->discard= video_discard; 3117 break; 3118 case AVMEDIA_TYPE_DATA: 3119 break; 3120 case AVMEDIA_TYPE_SUBTITLE: 3121 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name); 3122 if(subtitle_disable) 3123 st->discard = AVDISCARD_ALL; 3124 break; 3125 case AVMEDIA_TYPE_ATTACHMENT: 3126 case AVMEDIA_TYPE_UNKNOWN: 3127 nb_icodecs++; 3128 break; 3129 default: 3130 abort(); 3131 } 3132 } 3133 3134 input_files[nb_input_files] = ic; 3135 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp); 3136 /* dump the file content */ 3137 if (verbose >= 0) 3138 dump_format(ic, nb_input_files, filename, 0); 3139 3140 nb_input_files++; 3141 3142 video_channel = 0; 3143 3144 av_freep(&video_codec_name); 3145 av_freep(&audio_codec_name); 3146 av_freep(&subtitle_codec_name); 3147} 3148 3149static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr, 3150 int *has_subtitle_ptr) 3151{ 3152 int has_video, has_audio, has_subtitle, i, j; 3153 AVFormatContext *ic; 3154 3155 has_video = 0; 3156 has_audio = 0; 3157 has_subtitle = 0; 3158 for(j=0;j<nb_input_files;j++) { 3159 ic = input_files[j]; 3160 for(i=0;i<ic->nb_streams;i++) { 3161 AVCodecContext *enc = ic->streams[i]->codec; 3162 switch(enc->codec_type) { 3163 case AVMEDIA_TYPE_AUDIO: 3164 has_audio = 1; 3165 break; 3166 case AVMEDIA_TYPE_VIDEO: 3167 has_video = 1; 3168 break; 3169 case AVMEDIA_TYPE_SUBTITLE: 3170 has_subtitle = 1; 3171 break; 3172 case AVMEDIA_TYPE_DATA: 3173 case AVMEDIA_TYPE_ATTACHMENT: 3174 case AVMEDIA_TYPE_UNKNOWN: 3175 break; 3176 default: 3177 abort(); 3178 } 3179 } 3180 } 3181 *has_video_ptr = has_video; 3182 *has_audio_ptr = has_audio; 3183 *has_subtitle_ptr = has_subtitle; 3184} 3185 3186static void new_video_stream(AVFormatContext *oc) 3187{ 3188 AVStream *st; 3189 AVCodecContext *video_enc; 3190 enum CodecID codec_id; 3191 3192 st = av_new_stream(oc, oc->nb_streams); 3193 if (!st) { 3194 fprintf(stderr, "Could not alloc stream\n"); 3195 av_exit(1); 3196 } 3197 avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_VIDEO); 3198 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters; 3199 video_bitstream_filters= NULL; 3200 3201 avcodec_thread_init(st->codec, thread_count); 3202 3203 video_enc = st->codec; 3204 3205 if(video_codec_tag) 3206 video_enc->codec_tag= video_codec_tag; 3207 3208 if( (video_global_header&1) 3209 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){ 3210 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER; 3211 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER; 3212 } 3213 if(video_global_header&2){ 3214 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER; 3215 avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER; 3216 } 3217 3218 if (video_stream_copy) { 3219 st->stream_copy = 1; 3220 video_enc->codec_type = AVMEDIA_TYPE_VIDEO; 3221 video_enc->sample_aspect_ratio = 3222 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255); 3223 } else { 3224 const char *p; 3225 int i; 3226 AVCodec *codec; 3227 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1}; 3228 3229 if (video_codec_name) { 3230 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1, 3231 video_enc->strict_std_compliance); 3232 codec = avcodec_find_encoder_by_name(video_codec_name); 3233 output_codecs[nb_ocodecs] = codec; 3234 } else { 3235 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO); 3236 codec = avcodec_find_encoder(codec_id); 3237 } 3238 3239 video_enc->codec_id = codec_id; 3240 3241 set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM); 3242 3243 if (codec && codec->supported_framerates && !force_fps) 3244 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)]; 3245 video_enc->time_base.den = fps.num; 3246 video_enc->time_base.num = fps.den; 3247 3248 video_enc->width = frame_width + frame_padright + frame_padleft; 3249 video_enc->height = frame_height + frame_padtop + frame_padbottom; 3250 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255); 3251 video_enc->pix_fmt = frame_pix_fmt; 3252 st->sample_aspect_ratio = video_enc->sample_aspect_ratio; 3253 3254 choose_pixel_fmt(st, codec); 3255 3256 if (intra_only) 3257 video_enc->gop_size = 0; 3258 if (video_qscale || same_quality) { 3259 video_enc->flags |= CODEC_FLAG_QSCALE; 3260 video_enc->global_quality= 3261 st->quality = FF_QP2LAMBDA * video_qscale; 3262 } 3263 3264 if(intra_matrix) 3265 video_enc->intra_matrix = intra_matrix; 3266 if(inter_matrix) 3267 video_enc->inter_matrix = inter_matrix; 3268 3269 p= video_rc_override_string; 3270 for(i=0; p; i++){ 3271 int start, end, q; 3272 int e=sscanf(p, "%d,%d,%d", &start, &end, &q); 3273 if(e!=3){ 3274 fprintf(stderr, "error parsing rc_override\n"); 3275 av_exit(1); 3276 } 3277 video_enc->rc_override= 3278 av_realloc(video_enc->rc_override, 3279 sizeof(RcOverride)*(i+1)); 3280 video_enc->rc_override[i].start_frame= start; 3281 video_enc->rc_override[i].end_frame = end; 3282 if(q>0){ 3283 video_enc->rc_override[i].qscale= q; 3284 video_enc->rc_override[i].quality_factor= 1.0; 3285 } 3286 else{ 3287 video_enc->rc_override[i].qscale= 0; 3288 video_enc->rc_override[i].quality_factor= -q/100.0; 3289 } 3290 p= strchr(p, '/'); 3291 if(p) p++; 3292 } 3293 video_enc->rc_override_count=i; 3294 if (!video_enc->rc_initial_buffer_occupancy) 3295 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4; 3296 video_enc->me_threshold= me_threshold; 3297 video_enc->intra_dc_precision= intra_dc_precision - 8; 3298 3299 if (do_psnr) 3300 video_enc->flags|= CODEC_FLAG_PSNR; 3301 3302 /* two pass mode */ 3303 if (do_pass) { 3304 if (do_pass == 1) { 3305 video_enc->flags |= CODEC_FLAG_PASS1; 3306 } else { 3307 video_enc->flags |= CODEC_FLAG_PASS2; 3308 } 3309 } 3310 } 3311 nb_ocodecs++; 3312 if (video_language) { 3313 av_metadata_set2(&st->metadata, "language", video_language, 0); 3314 av_freep(&video_language); 3315 } 3316 3317 /* reset some key parameters */ 3318 video_disable = 0; 3319 av_freep(&video_codec_name); 3320 video_stream_copy = 0; 3321 frame_pix_fmt = PIX_FMT_NONE; 3322} 3323 3324static void new_audio_stream(AVFormatContext *oc) 3325{ 3326 AVStream *st; 3327 AVCodecContext *audio_enc; 3328 enum CodecID codec_id; 3329 3330 st = av_new_stream(oc, oc->nb_streams); 3331 if (!st) { 3332 fprintf(stderr, "Could not alloc stream\n"); 3333 av_exit(1); 3334 } 3335 avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_AUDIO); 3336 3337 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters; 3338 audio_bitstream_filters= NULL; 3339 3340 avcodec_thread_init(st->codec, thread_count); 3341 3342 audio_enc = st->codec; 3343 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO; 3344 3345 if(audio_codec_tag) 3346 audio_enc->codec_tag= audio_codec_tag; 3347 3348 if (oc->oformat->flags & AVFMT_GLOBALHEADER) { 3349 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER; 3350 avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER; 3351 } 3352 if (audio_stream_copy) { 3353 st->stream_copy = 1; 3354 audio_enc->channels = audio_channels; 3355 audio_enc->sample_rate = audio_sample_rate; 3356 } else { 3357 AVCodec *codec; 3358 3359 set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM); 3360 3361 if (audio_codec_name) { 3362 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1, 3363 audio_enc->strict_std_compliance); 3364 codec = avcodec_find_encoder_by_name(audio_codec_name); 3365 output_codecs[nb_ocodecs] = codec; 3366 } else { 3367 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO); 3368 codec = avcodec_find_encoder(codec_id); 3369 } 3370 audio_enc->codec_id = codec_id; 3371 3372 if (audio_qscale > QSCALE_NONE) { 3373 audio_enc->flags |= CODEC_FLAG_QSCALE; 3374 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale; 3375 } 3376 audio_enc->channels = audio_channels; 3377 audio_enc->sample_fmt = audio_sample_fmt; 3378 audio_enc->sample_rate = audio_sample_rate; 3379 audio_enc->channel_layout = channel_layout; 3380 if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels) 3381 audio_enc->channel_layout = 0; 3382 choose_sample_fmt(st, codec); 3383 choose_sample_rate(st, codec); 3384 } 3385 nb_ocodecs++; 3386 audio_enc->time_base= (AVRational){1, audio_sample_rate}; 3387 if (audio_language) { 3388 av_metadata_set2(&st->metadata, "language", audio_language, 0); 3389 av_freep(&audio_language); 3390 } 3391 3392 /* reset some key parameters */ 3393 audio_disable = 0; 3394 av_freep(&audio_codec_name); 3395 audio_stream_copy = 0; 3396} 3397 3398static void new_subtitle_stream(AVFormatContext *oc) 3399{ 3400 AVStream *st; 3401 AVCodecContext *subtitle_enc; 3402 3403 st = av_new_stream(oc, oc->nb_streams); 3404 if (!st) { 3405 fprintf(stderr, "Could not alloc stream\n"); 3406 av_exit(1); 3407 } 3408 avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_SUBTITLE); 3409 3410 bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters; 3411 subtitle_bitstream_filters= NULL; 3412 3413 subtitle_enc = st->codec; 3414 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE; 3415 3416 if(subtitle_codec_tag) 3417 subtitle_enc->codec_tag= subtitle_codec_tag; 3418 3419 if (subtitle_stream_copy) { 3420 st->stream_copy = 1; 3421 } else { 3422 set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM); 3423 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1, 3424 subtitle_enc->strict_std_compliance); 3425 output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name); 3426 } 3427 nb_ocodecs++; 3428 3429 if (subtitle_language) { 3430 av_metadata_set2(&st->metadata, "language", subtitle_language, 0); 3431 av_freep(&subtitle_language); 3432 } 3433 3434 subtitle_disable = 0; 3435 av_freep(&subtitle_codec_name); 3436 subtitle_stream_copy = 0; 3437} 3438 3439static void opt_new_audio_stream(void) 3440{ 3441 AVFormatContext *oc; 3442 if (nb_output_files <= 0) { 3443 fprintf(stderr, "At least one output file must be specified\n"); 3444 av_exit(1); 3445 } 3446 oc = output_files[nb_output_files - 1]; 3447 new_audio_stream(oc); 3448} 3449 3450static void opt_new_video_stream(void) 3451{ 3452 AVFormatContext *oc; 3453 if (nb_output_files <= 0) { 3454 fprintf(stderr, "At least one output file must be specified\n"); 3455 av_exit(1); 3456 } 3457 oc = output_files[nb_output_files - 1]; 3458 new_video_stream(oc); 3459} 3460 3461static void opt_new_subtitle_stream(void) 3462{ 3463 AVFormatContext *oc; 3464 if (nb_output_files <= 0) { 3465 fprintf(stderr, "At least one output file must be specified\n"); 3466 av_exit(1); 3467 } 3468 oc = output_files[nb_output_files - 1]; 3469 new_subtitle_stream(oc); 3470} 3471 3472static void opt_output_file(const char *filename) 3473{ 3474 AVFormatContext *oc; 3475 int err, use_video, use_audio, use_subtitle; 3476 int input_has_video, input_has_audio, input_has_subtitle; 3477 AVFormatParameters params, *ap = ¶ms; 3478 AVOutputFormat *file_oformat; 3479 3480 if (!strcmp(filename, "-")) 3481 filename = "pipe:"; 3482 3483 oc = avformat_alloc_context(); 3484 if (!oc) { 3485 print_error(filename, AVERROR(ENOMEM)); 3486 av_exit(1); 3487 } 3488 3489 if (last_asked_format) { 3490 file_oformat = av_guess_format(last_asked_format, NULL, NULL); 3491 if (!file_oformat) { 3492 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format); 3493 av_exit(1); 3494 } 3495 last_asked_format = NULL; 3496 } else { 3497 file_oformat = av_guess_format(NULL, filename, NULL); 3498 if (!file_oformat) { 3499 fprintf(stderr, "Unable to find a suitable output format for '%s'\n", 3500 filename); 3501 av_exit(1); 3502 } 3503 } 3504 3505 oc->oformat = file_oformat; 3506 av_strlcpy(oc->filename, filename, sizeof(oc->filename)); 3507 3508 if (!strcmp(file_oformat->name, "ffm") && 3509 av_strstart(filename, "http:", NULL)) { 3510 /* special case for files sent to ffserver: we get the stream 3511 parameters from ffserver */ 3512 int err = read_ffserver_streams(oc, filename); 3513 if (err < 0) { 3514 print_error(filename, err); 3515 av_exit(1); 3516 } 3517 } else { 3518 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name; 3519 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name; 3520 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name; 3521 3522 /* disable if no corresponding type found and at least one 3523 input file */ 3524 if (nb_input_files > 0) { 3525 check_audio_video_sub_inputs(&input_has_video, &input_has_audio, 3526 &input_has_subtitle); 3527 if (!input_has_video) 3528 use_video = 0; 3529 if (!input_has_audio) 3530 use_audio = 0; 3531 if (!input_has_subtitle) 3532 use_subtitle = 0; 3533 } 3534 3535 /* manual disable */ 3536 if (audio_disable) { 3537 use_audio = 0; 3538 } 3539 if (video_disable) { 3540 use_video = 0; 3541 } 3542 if (subtitle_disable) { 3543 use_subtitle = 0; 3544 } 3545 3546 if (use_video) { 3547 new_video_stream(oc); 3548 } 3549 3550 if (use_audio) { 3551 new_audio_stream(oc); 3552 } 3553 3554 if (use_subtitle) { 3555 new_subtitle_stream(oc); 3556 } 3557 3558 oc->timestamp = rec_timestamp; 3559 3560 for(; metadata_count>0; metadata_count--){ 3561 av_metadata_set2(&oc->metadata, metadata[metadata_count-1].key, 3562 metadata[metadata_count-1].value, 0); 3563 } 3564 av_metadata_conv(oc, oc->oformat->metadata_conv, NULL); 3565 } 3566 3567 output_files[nb_output_files++] = oc; 3568 3569 /* check filename in case of an image number is expected */ 3570 if (oc->oformat->flags & AVFMT_NEEDNUMBER) { 3571 if (!av_filename_number_test(oc->filename)) { 3572 print_error(oc->filename, AVERROR_NUMEXPECTED); 3573 av_exit(1); 3574 } 3575 } 3576 3577 if (!(oc->oformat->flags & AVFMT_NOFILE)) { 3578 /* test if it already exists to avoid loosing precious files */ 3579 if (!file_overwrite && 3580 (strchr(filename, ':') == NULL || 3581 filename[1] == ':' || 3582 av_strstart(filename, "file:", NULL))) { 3583 if (url_exist(filename)) { 3584 if (!using_stdin) { 3585 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename); 3586 fflush(stderr); 3587 if (!read_yesno()) { 3588 fprintf(stderr, "Not overwriting - exiting\n"); 3589 av_exit(1); 3590 } 3591 } 3592 else { 3593 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename); 3594 av_exit(1); 3595 } 3596 } 3597 } 3598 3599 /* open the file */ 3600 if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) { 3601 print_error(filename, err); 3602 av_exit(1); 3603 } 3604 } 3605 3606 memset(ap, 0, sizeof(*ap)); 3607 if (av_set_parameters(oc, ap) < 0) { 3608 fprintf(stderr, "%s: Invalid encoding parameters\n", 3609 oc->filename); 3610 av_exit(1); 3611 } 3612 3613 oc->preload= (int)(mux_preload*AV_TIME_BASE); 3614 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE); 3615 oc->loop_output = loop_output; 3616 oc->flags |= AVFMT_FLAG_NONBLOCK; 3617 3618 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM); 3619} 3620 3621/* same option as mencoder */ 3622static void opt_pass(const char *pass_str) 3623{ 3624 int pass; 3625 pass = atoi(pass_str); 3626 if (pass != 1 && pass != 2) { 3627 fprintf(stderr, "pass number can be only 1 or 2\n"); 3628 av_exit(1); 3629 } 3630 do_pass = pass; 3631} 3632 3633static int64_t getutime(void) 3634{ 3635#if HAVE_GETRUSAGE 3636 struct rusage rusage; 3637 3638 getrusage(RUSAGE_SELF, &rusage); 3639 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec; 3640#elif HAVE_GETPROCESSTIMES 3641 HANDLE proc; 3642 FILETIME c, e, k, u; 3643 proc = GetCurrentProcess(); 3644 GetProcessTimes(proc, &c, &e, &k, &u); 3645 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10; 3646#else 3647 return av_gettime(); 3648#endif 3649} 3650 3651static int64_t getmaxrss(void) 3652{ 3653#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS 3654 struct rusage rusage; 3655 getrusage(RUSAGE_SELF, &rusage); 3656 return (int64_t)rusage.ru_maxrss * 1024; 3657#elif HAVE_GETPROCESSMEMORYINFO 3658 HANDLE proc; 3659 PROCESS_MEMORY_COUNTERS memcounters; 3660 proc = GetCurrentProcess(); 3661 memcounters.cb = sizeof(memcounters); 3662 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters)); 3663 return memcounters.PeakPagefileUsage; 3664#else 3665 return 0; 3666#endif 3667} 3668 3669static void parse_matrix_coeffs(uint16_t *dest, const char *str) 3670{ 3671 int i; 3672 const char *p = str; 3673 for(i = 0;; i++) { 3674 dest[i] = atoi(p); 3675 if(i == 63) 3676 break; 3677 p = strchr(p, ','); 3678 if(!p) { 3679 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i); 3680 av_exit(1); 3681 } 3682 p++; 3683 } 3684} 3685 3686static void opt_inter_matrix(const char *arg) 3687{ 3688 inter_matrix = av_mallocz(sizeof(uint16_t) * 64); 3689 parse_matrix_coeffs(inter_matrix, arg); 3690} 3691 3692static void opt_intra_matrix(const char *arg) 3693{ 3694 intra_matrix = av_mallocz(sizeof(uint16_t) * 64); 3695 parse_matrix_coeffs(intra_matrix, arg); 3696} 3697 3698/** 3699 * Trivial log callback. 3700 * Only suitable for show_help and similar since it lacks prefix handling. 3701 */ 3702static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl) 3703{ 3704 vfprintf(stdout, fmt, vl); 3705} 3706 3707static void show_usage(void) 3708{ 3709 printf("Hyper fast Audio and Video encoder\n"); 3710 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n"); 3711 printf("\n"); 3712} 3713 3714static void show_help(void) 3715{ 3716 av_log_set_callback(log_callback_help); 3717 show_usage(); 3718 show_help_options(options, "Main options:\n", 3719 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0); 3720 show_help_options(options, "\nAdvanced options:\n", 3721 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 3722 OPT_EXPERT); 3723 show_help_options(options, "\nVideo options:\n", 3724 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 3725 OPT_VIDEO); 3726 show_help_options(options, "\nAdvanced Video options:\n", 3727 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 3728 OPT_VIDEO | OPT_EXPERT); 3729 show_help_options(options, "\nAudio options:\n", 3730 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 3731 OPT_AUDIO); 3732 show_help_options(options, "\nAdvanced Audio options:\n", 3733 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 3734 OPT_AUDIO | OPT_EXPERT); 3735 show_help_options(options, "\nSubtitle options:\n", 3736 OPT_SUBTITLE | OPT_GRAB, 3737 OPT_SUBTITLE); 3738 show_help_options(options, "\nAudio/Video grab options:\n", 3739 OPT_GRAB, 3740 OPT_GRAB); 3741 printf("\n"); 3742 av_opt_show(avcodec_opts[0], NULL); 3743 printf("\n"); 3744 av_opt_show(avformat_opts, NULL); 3745 printf("\n"); 3746 av_opt_show(sws_opts, NULL); 3747} 3748 3749static void opt_target(const char *arg) 3750{ 3751 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN; 3752 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"}; 3753 3754 if(!strncmp(arg, "pal-", 4)) { 3755 norm = PAL; 3756 arg += 4; 3757 } else if(!strncmp(arg, "ntsc-", 5)) { 3758 norm = NTSC; 3759 arg += 5; 3760 } else if(!strncmp(arg, "film-", 5)) { 3761 norm = FILM; 3762 arg += 5; 3763 } else { 3764 int fr; 3765 /* Calculate FR via float to avoid int overflow */ 3766 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den); 3767 if(fr == 25000) { 3768 norm = PAL; 3769 } else if((fr == 29970) || (fr == 23976)) { 3770 norm = NTSC; 3771 } else { 3772 /* Try to determine PAL/NTSC by peeking in the input files */ 3773 if(nb_input_files) { 3774 int i, j; 3775 for(j = 0; j < nb_input_files; j++) { 3776 for(i = 0; i < input_files[j]->nb_streams; i++) { 3777 AVCodecContext *c = input_files[j]->streams[i]->codec; 3778 if(c->codec_type != AVMEDIA_TYPE_VIDEO) 3779 continue; 3780 fr = c->time_base.den * 1000 / c->time_base.num; 3781 if(fr == 25000) { 3782 norm = PAL; 3783 break; 3784 } else if((fr == 29970) || (fr == 23976)) { 3785 norm = NTSC; 3786 break; 3787 } 3788 } 3789 if(norm != UNKNOWN) 3790 break; 3791 } 3792 } 3793 } 3794 if(verbose && norm != UNKNOWN) 3795 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC"); 3796 } 3797 3798 if(norm == UNKNOWN) { 3799 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n"); 3800 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n"); 3801 fprintf(stderr, "or set a framerate with \"-r xxx\".\n"); 3802 av_exit(1); 3803 } 3804 3805 if(!strcmp(arg, "vcd")) { 3806 3807 opt_video_codec("mpeg1video"); 3808 opt_audio_codec("mp2"); 3809 opt_format("vcd"); 3810 3811 opt_frame_size(norm == PAL ? "352x288" : "352x240"); 3812 opt_frame_rate(NULL, frame_rates[norm]); 3813 opt_default("g", norm == PAL ? "15" : "18"); 3814 3815 opt_default("b", "1150000"); 3816 opt_default("maxrate", "1150000"); 3817 opt_default("minrate", "1150000"); 3818 opt_default("bufsize", "327680"); // 40*1024*8; 3819 3820 opt_default("ab", "224000"); 3821 audio_sample_rate = 44100; 3822 audio_channels = 2; 3823 3824 opt_default("packetsize", "2324"); 3825 opt_default("muxrate", "1411200"); // 2352 * 75 * 8; 3826 3827 /* We have to offset the PTS, so that it is consistent with the SCR. 3828 SCR starts at 36000, but the first two packs contain only padding 3829 and the first pack from the other stream, respectively, may also have 3830 been written before. 3831 So the real data starts at SCR 36000+3*1200. */ 3832 mux_preload= (36000+3*1200) / 90000.0; //0.44 3833 } else if(!strcmp(arg, "svcd")) { 3834 3835 opt_video_codec("mpeg2video"); 3836 opt_audio_codec("mp2"); 3837 opt_format("svcd"); 3838 3839 opt_frame_size(norm == PAL ? "480x576" : "480x480"); 3840 opt_frame_rate(NULL, frame_rates[norm]); 3841 opt_default("g", norm == PAL ? "15" : "18"); 3842 3843 opt_default("b", "2040000"); 3844 opt_default("maxrate", "2516000"); 3845 opt_default("minrate", "0"); //1145000; 3846 opt_default("bufsize", "1835008"); //224*1024*8; 3847 opt_default("flags", "+scan_offset"); 3848 3849 3850 opt_default("ab", "224000"); 3851 audio_sample_rate = 44100; 3852 3853 opt_default("packetsize", "2324"); 3854 3855 } else if(!strcmp(arg, "dvd")) { 3856 3857 opt_video_codec("mpeg2video"); 3858 opt_audio_codec("ac3"); 3859 opt_format("dvd"); 3860 3861 opt_frame_size(norm == PAL ? "720x576" : "720x480"); 3862 opt_frame_rate(NULL, frame_rates[norm]); 3863 opt_default("g", norm == PAL ? "15" : "18"); 3864 3865 opt_default("b", "6000000"); 3866 opt_default("maxrate", "9000000"); 3867 opt_default("minrate", "0"); //1500000; 3868 opt_default("bufsize", "1835008"); //224*1024*8; 3869 3870 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack. 3871 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8 3872 3873 opt_default("ab", "448000"); 3874 audio_sample_rate = 48000; 3875 3876 } else if(!strncmp(arg, "dv", 2)) { 3877 3878 opt_format("dv"); 3879 3880 opt_frame_size(norm == PAL ? "720x576" : "720x480"); 3881 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" : 3882 (norm == PAL ? "yuv420p" : "yuv411p")); 3883 opt_frame_rate(NULL, frame_rates[norm]); 3884 3885 audio_sample_rate = 48000; 3886 audio_channels = 2; 3887 3888 } else { 3889 fprintf(stderr, "Unknown target: %s\n", arg); 3890 av_exit(1); 3891 } 3892} 3893 3894static void opt_vstats_file (const char *arg) 3895{ 3896 av_free (vstats_filename); 3897 vstats_filename=av_strdup (arg); 3898} 3899 3900static void opt_vstats (void) 3901{ 3902 char filename[40]; 3903 time_t today2 = time(NULL); 3904 struct tm *today = localtime(&today2); 3905 3906 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min, 3907 today->tm_sec); 3908 opt_vstats_file(filename); 3909} 3910 3911static int opt_bsf(const char *opt, const char *arg) 3912{ 3913 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '=' 3914 AVBitStreamFilterContext **bsfp; 3915 3916 if(!bsfc){ 3917 fprintf(stderr, "Unknown bitstream filter %s\n", arg); 3918 av_exit(1); 3919 } 3920 3921 bsfp= *opt == 'v' ? &video_bitstream_filters : 3922 *opt == 'a' ? &audio_bitstream_filters : 3923 &subtitle_bitstream_filters; 3924 while(*bsfp) 3925 bsfp= &(*bsfp)->next; 3926 3927 *bsfp= bsfc; 3928 3929 return 0; 3930} 3931 3932static int opt_preset(const char *opt, const char *arg) 3933{ 3934 FILE *f=NULL; 3935 char filename[1000], tmp[1000], tmp2[1000], line[1000]; 3936 int i; 3937 const char *base[3]= { getenv("FFMPEG_DATADIR"), 3938 getenv("HOME"), 3939 FFMPEG_DATADIR, 3940 }; 3941 3942 if (*opt != 'f') { 3943 for(i=0; i<3 && !f; i++){ 3944 if(!base[i]) 3945 continue; 3946 snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", arg); 3947 f= fopen(filename, "r"); 3948 if(!f){ 3949 char *codec_name= *opt == 'v' ? video_codec_name : 3950 *opt == 'a' ? audio_codec_name : 3951 subtitle_codec_name; 3952 snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", codec_name, arg); 3953 f= fopen(filename, "r"); 3954 } 3955 } 3956 } else { 3957 av_strlcpy(filename, arg, sizeof(filename)); 3958 f= fopen(filename, "r"); 3959 } 3960 3961 if(!f){ 3962 fprintf(stderr, "File for preset '%s' not found\n", arg); 3963 av_exit(1); 3964 } 3965 3966 while(!feof(f)){ 3967 int e= fscanf(f, "%999[^\n]\n", line) - 1; 3968 if(line[0] == '#' && !e) 3969 continue; 3970 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2; 3971 if(e){ 3972 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line); 3973 av_exit(1); 3974 } 3975 if(!strcmp(tmp, "acodec")){ 3976 opt_audio_codec(tmp2); 3977 }else if(!strcmp(tmp, "vcodec")){ 3978 opt_video_codec(tmp2); 3979 }else if(!strcmp(tmp, "scodec")){ 3980 opt_subtitle_codec(tmp2); 3981 }else if(opt_default(tmp, tmp2) < 0){ 3982 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2); 3983 av_exit(1); 3984 } 3985 } 3986 3987 fclose(f); 3988 3989 return 0; 3990} 3991 3992static const OptionDef options[] = { 3993 /* main options */ 3994#include "cmdutils_common_opts.h" 3995 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" }, 3996 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" }, 3997 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" }, 3998 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" }, 3999 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" }, 4000 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" }, 4001 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, // 4002 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" }, 4003 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" }, 4004 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" }, 4005 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" }, 4006 { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" }, 4007 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" }, 4008 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark}, 4009 "add timings for benchmarking" }, 4010 { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" }, 4011 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump}, 4012 "dump each input packet" }, 4013 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump}, 4014 "when dumping packets, also dump the payload" }, 4015 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" }, 4016 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" }, 4017 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "number of times to loop output in formats that support looping (0 loops forever)", "" }, 4018 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" }, 4019 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" }, 4020 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" }, 4021 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" }, 4022 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" }, 4023 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" }, 4024 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" }, 4025 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" }, 4026 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, // 4027 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" }, 4028 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" }, 4029 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" }, 4030 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" }, 4031 4032 /* video options */ 4033 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" }, 4034 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" }, 4035 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" }, 4036 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" }, 4037 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" }, 4038 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" }, 4039 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format, 'list' as argument shows all the pixel formats supported", "format" }, 4040 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" }, 4041 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" }, 4042 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" }, 4043 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" }, 4044 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" }, 4045 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" }, 4046 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" }, 4047 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" }, 4048 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" }, 4049 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"}, 4050 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" }, 4051 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" }, 4052 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" }, 4053 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" }, 4054 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" }, 4055 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" }, 4056 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality}, 4057 "use same video quality as source (implies VBR)" }, 4058 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" }, 4059 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" }, 4060 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace}, 4061 "deinterlace pictures" }, 4062 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" }, 4063 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" }, 4064 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" }, 4065 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" }, 4066 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" }, 4067 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" }, 4068 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" }, 4069 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" }, 4070 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" }, 4071 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" }, 4072 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" }, 4073 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" }, 4074 4075 /* audio options */ 4076 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" }, 4077 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" }, 4078 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", }, 4079 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" }, 4080 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" }, 4081 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" }, 4082 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" }, 4083 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" }, 4084 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, // 4085 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" }, 4086 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" }, 4087 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_sample_fmt}, "set sample format, 'list' as argument shows all the sample formats supported", "format" }, 4088 4089 /* subtitle options */ 4090 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" }, 4091 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" }, 4092 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" }, 4093 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" }, 4094 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" }, 4095 4096 /* grab options */ 4097 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" }, 4098 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" }, 4099 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" }, 4100 4101 /* muxer options */ 4102 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" }, 4103 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" }, 4104 4105 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" }, 4106 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" }, 4107 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" }, 4108 4109 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" }, 4110 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" }, 4111 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" }, 4112 { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" }, 4113 4114 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" }, 4115 { NULL, }, 4116}; 4117 4118int main(int argc, char **argv) 4119{ 4120 int i; 4121 int64_t ti; 4122 4123 avcodec_register_all(); 4124#if CONFIG_AVDEVICE 4125 avdevice_register_all(); 4126#endif 4127 av_register_all(); 4128 4129#if HAVE_ISATTY 4130 if(isatty(STDIN_FILENO)) 4131 url_set_interrupt_cb(decode_interrupt_cb); 4132#endif 4133 4134 for(i=0; i<AVMEDIA_TYPE_NB; i++){ 4135 avcodec_opts[i]= avcodec_alloc_context2(i); 4136 } 4137 avformat_opts = avformat_alloc_context(); 4138 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL); 4139 4140 show_banner(); 4141 4142 /* parse options */ 4143 parse_options(argc, argv, options, opt_output_file); 4144 4145 if(nb_output_files <= 0 && nb_input_files == 0) { 4146 show_usage(); 4147 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n"); 4148 av_exit(1); 4149 } 4150 4151 /* file converter / grab */ 4152 if (nb_output_files <= 0) { 4153 fprintf(stderr, "At least one output file must be specified\n"); 4154 av_exit(1); 4155 } 4156 4157 if (nb_input_files == 0) { 4158 fprintf(stderr, "At least one input file must be specified\n"); 4159 av_exit(1); 4160 } 4161 4162 ti = getutime(); 4163 if (av_transcode(output_files, nb_output_files, input_files, nb_input_files, 4164 stream_maps, nb_stream_maps) < 0) 4165 av_exit(1); 4166 ti = getutime() - ti; 4167 if (do_benchmark) { 4168 int maxrss = getmaxrss() / 1024; 4169 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss); 4170 } 4171 4172 return av_exit(0); 4173} 4174