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