3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 #define HAVE_AV_CONFIG_H
22 #include "framehook.h"
27 #include <sys/ioctl.h>
30 #include <sys/resource.h>
34 #include <sys/types.h>
35 #include <sys/select.h>
38 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
43 #if !defined(INFINITY) && defined(HUGE_VAL)
44 #define INFINITY HUGE_VAL
47 /* select an input stream for an output stream */
48 typedef struct AVStreamMap {
53 extern const OptionDef options[];
55 static void show_help(void);
56 static void show_license(void);
60 static AVFormatContext *input_files[MAX_FILES];
61 static int nb_input_files = 0;
63 static AVFormatContext *output_files[MAX_FILES];
64 static int nb_output_files = 0;
66 static AVStreamMap stream_maps[MAX_FILES];
67 static int nb_stream_maps;
69 static AVInputFormat *file_iformat;
70 static AVOutputFormat *file_oformat;
71 static AVImageFormat *image_format;
72 static int frame_width = 160;
73 static int frame_height = 128;
74 static float frame_aspect_ratio = 0;
75 static enum PixelFormat frame_pix_fmt = PIX_FMT_YUV420P;
76 static int frame_padtop = 0;
77 static int frame_padbottom = 0;
78 static int frame_padleft = 0;
79 static int frame_padright = 0;
80 static int padcolor[3] = {16,128,128}; /* default to black */
81 static int frame_topBand = 0;
82 static int frame_bottomBand = 0;
83 static int frame_leftBand = 0;
84 static int frame_rightBand = 0;
85 static int frame_rate = 25;
86 static int frame_rate_base = 1;
87 static int video_bit_rate = 200*1000;
88 static int video_bit_rate_tolerance = 4000*1000;
89 static float video_qscale = 0;
90 static int video_qmin = 2;
91 static int video_qmax = 31;
92 static int video_lmin = 2*FF_QP2LAMBDA;
93 static int video_lmax = 31*FF_QP2LAMBDA;
94 static int video_mb_qmin = 2;
95 static int video_mb_qmax = 31;
96 static int video_qdiff = 3;
97 static float video_qblur = 0.5;
98 static float video_qcomp = 0.5;
99 static uint16_t *intra_matrix = NULL;
100 static uint16_t *inter_matrix = NULL;
101 #if 0 //experimental, (can be removed)
102 static float video_rc_qsquish=1.0;
103 static float video_rc_qmod_amp=0;
104 static int video_rc_qmod_freq=0;
106 static char *video_rc_override_string=NULL;
107 static char *video_rc_eq="tex^qComp";
108 static int video_rc_buffer_size=0;
109 static float video_rc_buffer_aggressivity=1.0;
110 static int video_rc_max_rate=0;
111 static int video_rc_min_rate=0;
112 static float video_rc_initial_cplx=0;
113 static float video_b_qfactor = 1.25;
114 static float video_b_qoffset = 1.25;
115 static float video_i_qfactor = -0.8;
116 static float video_i_qoffset = 0.0;
117 static int video_intra_quant_bias= FF_DEFAULT_QUANT_BIAS;
118 static int video_inter_quant_bias= FF_DEFAULT_QUANT_BIAS;
119 static int me_method = ME_EPZS;
120 static int video_disable = 0;
121 static int video_codec_id = CODEC_ID_NONE;
122 static int same_quality = 0;
123 static int b_frames = 0;
124 static int mb_decision = FF_MB_DECISION_SIMPLE;
125 static int ildct_cmp = FF_CMP_VSAD;
126 static int mb_cmp = FF_CMP_SAD;
127 static int sub_cmp = FF_CMP_SAD;
128 static int cmp = FF_CMP_SAD;
129 static int pre_cmp = FF_CMP_SAD;
130 static int pre_me = 0;
131 static float lumi_mask = 0;
132 static float dark_mask = 0;
133 static float scplx_mask = 0;
134 static float tcplx_mask = 0;
135 static float p_mask = 0;
136 static int use_4mv = 0;
137 static int use_obmc = 0;
138 static int use_loop = 0;
139 static int use_aic = 0;
140 static int use_aiv = 0;
141 static int use_umv = 0;
142 static int use_ss = 0;
143 static int use_alt_scan = 0;
144 static int use_trell = 0;
145 static int use_scan_offset = 0;
146 static int use_qpel = 0;
148 static int closed_gop = 0;
149 static int do_deinterlace = 0;
150 static int do_interlace_dct = 0;
151 static int do_interlace_me = 0;
152 static int workaround_bugs = FF_BUG_AUTODETECT;
153 static int error_resilience = 2;
154 static int error_concealment = 3;
155 static int dct_algo = 0;
156 static int idct_algo = 0;
157 static int use_part = 0;
158 static int packet_size = 0;
159 static int error_rate = 0;
160 static int strict = 0;
161 static int top_field_first = -1;
162 static int noise_reduction = 0;
163 static int sc_threshold = 0;
164 static int debug = 0;
165 static int debug_mv = 0;
166 static int me_threshold = 0;
167 static int mb_threshold = 0;
168 static int intra_dc_precision = 0;
169 static int coder = 0;
170 static int context = 0;
171 static int predictor = 0;
172 extern int loop_input; /* currently a hack */
174 static int gop_size = 12;
175 static int intra_only = 0;
176 static int audio_sample_rate = 44100;
177 static int audio_bit_rate = 64000;
178 static int audio_disable = 0;
179 static int audio_channels = 1;
180 static int audio_codec_id = CODEC_ID_NONE;
182 static int64_t recording_time = 0;
183 static int64_t start_time = 0;
184 static int64_t rec_timestamp = 0;
185 static int file_overwrite = 0;
186 static char *str_title = NULL;
187 static char *str_author = NULL;
188 static char *str_copyright = NULL;
189 static char *str_comment = NULL;
190 static int do_benchmark = 0;
191 static int do_hex_dump = 0;
192 static int do_pkt_dump = 0;
193 static int do_psnr = 0;
194 static int do_vstats = 0;
195 static int do_pass = 0;
196 static int bitexact = 0;
197 static char *pass_logfilename = NULL;
198 static int audio_stream_copy = 0;
199 static int video_stream_copy = 0;
200 static int sync_method= 1;
202 static int rate_emu = 0;
204 static char *video_grab_format = "video4linux";
205 static char *video_device = NULL;
206 static int video_channel = 0;
207 static char *video_standard = "ntsc";
209 static char *audio_grab_format = "audio_device";
210 static char *audio_device = NULL;
212 static int using_stdin = 0;
213 static int using_vhook = 0;
214 static int verbose = 1;
215 static int thread_count= 1;
216 static int q_pressed = 0;
217 static int me_range = 0;
218 static int64_t video_size = 0;
219 static int64_t audio_size = 0;
220 static int64_t extra_size = 0;
222 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
224 typedef struct AVOutputStream {
225 int file_index; /* file index */
226 int index; /* stream index in the output file */
227 int source_index; /* AVInputStream index */
228 AVStream *st; /* stream in the output file */
229 int encoding_needed; /* true if encoding needed for this stream */
231 /* input pts and corresponding output pts
234 double sync_ipts_offset;
237 int video_resample; /* video_resample and video_crop are mutually exclusive */
238 AVFrame pict_tmp; /* temporary image for resampling */
239 ImgReSampleContext *img_resample_ctx; /* for image resampling */
241 int video_crop; /* video_resample and video_crop are mutually exclusive */
242 int topBand; /* cropping area sizes */
245 int video_pad; /* video_resample and video_pad are mutually exclusive */
246 int padtop; /* padding area sizes */
253 ReSampleContext *resample; /* for audio resampling */
254 FifoBuffer fifo; /* for compression: one audio fifo per codec */
258 typedef struct AVInputStream {
262 int discard; /* true if stream data should be discarded */
263 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
264 int64_t sample_index; /* current sample */
266 int64_t start; /* time when read started */
267 unsigned long frame; /* current frame */
268 int64_t next_pts; /* synthetic pts for cases where pkt.pts
270 int64_t pts; /* current pts */
273 typedef struct AVInputFile {
274 int eof_reached; /* true if eof reached */
275 int ist_index; /* index of first stream in ist_table */
276 int buffer_size; /* current total buffer size */
277 int buffer_size_max; /* buffer size at which we consider we can stop
279 int nb_streams; /* nb streams we are aware of */
284 /* init terminal so that we can grab keys */
285 static struct termios oldtty;
287 static void term_exit(void)
289 tcsetattr (0, TCSANOW, &oldtty);
292 static volatile sig_atomic_t received_sigterm = 0;
295 sigterm_handler(int sig)
297 received_sigterm = sig;
301 static void term_init(void)
308 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
309 |INLCR|IGNCR|ICRNL|IXON);
310 tty.c_oflag |= OPOST;
311 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
312 tty.c_cflag &= ~(CSIZE|PARENB);
317 tcsetattr (0, TCSANOW, &tty);
319 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
320 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
321 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
323 register a function to be called at normal program termination
326 #ifdef CONFIG_BEOS_NETSERVER
327 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
331 /* read a key without blocking */
332 static int read_key(void)
336 #ifndef CONFIG_BEOS_NETSERVER
344 n = select(1, &rfds, NULL, NULL, &tv);
356 static int decode_interrupt_cb(void)
358 return q_pressed || (q_pressed = read_key() == 'q');
363 static volatile int received_sigterm = 0;
365 /* no interactive support */
366 static void term_exit(void)
370 static void term_init(void)
374 static int read_key(void)
381 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
386 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
389 /* copy stream format */
390 s->nb_streams = ic->nb_streams;
391 for(i=0;i<ic->nb_streams;i++) {
394 st = av_mallocz(sizeof(AVStream));
395 memcpy(st, ic->streams[i], sizeof(AVStream));
399 av_close_input_file(ic);
403 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
405 static void do_audio_out(AVFormatContext *s,
408 unsigned char *buf, int size)
411 static uint8_t *audio_buf = NULL;
412 static uint8_t *audio_out = NULL;
413 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
415 int size_out, frame_bytes, ret;
418 /* SC: dynamic allocation of buffers */
420 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
422 audio_out = av_malloc(audio_out_size);
423 if (!audio_buf || !audio_out)
424 return; /* Should signal an error ! */
427 enc = &ost->st->codec;
429 if (ost->audio_resample) {
431 size_out = audio_resample(ost->resample,
432 (short *)buftmp, (short *)buf,
433 size / (ist->st->codec.channels * 2));
434 size_out = size_out * enc->channels * 2;
440 /* now encode as many frames as possible */
441 if (enc->frame_size > 1) {
442 /* output resampled raw samples */
443 fifo_write(&ost->fifo, buftmp, size_out,
446 frame_bytes = enc->frame_size * 2 * enc->channels;
448 while (fifo_read(&ost->fifo, audio_buf, frame_bytes,
449 &ost->fifo.rptr) == 0) {
450 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
453 av_write_frame(s, ost->index, audio_out, ret);
456 /* output a pcm frame */
457 /* XXX: change encoding codec API to avoid this ? */
458 switch(enc->codec->id) {
459 case CODEC_ID_PCM_S16LE:
460 case CODEC_ID_PCM_S16BE:
461 case CODEC_ID_PCM_U16LE:
462 case CODEC_ID_PCM_U16BE:
465 size_out = size_out >> 1;
468 ret = avcodec_encode_audio(enc, audio_out, size_out,
471 av_write_frame(s, ost->index, audio_out, ret);
475 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
479 AVPicture picture_tmp;
482 dec = &ist->st->codec;
484 /* deinterlace : must be done before any resize */
485 if (do_deinterlace || using_vhook) {
488 /* create temporary picture */
489 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
490 buf = av_malloc(size);
494 picture2 = &picture_tmp;
495 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
498 if(avpicture_deinterlace(picture2, picture,
499 dec->pix_fmt, dec->width, dec->height) < 0) {
500 /* if error, do not deinterlace */
506 if (img_convert(picture2, dec->pix_fmt, picture,
507 dec->pix_fmt, dec->width, dec->height) < 0) {
508 /* if error, do not copy */
518 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
520 if (picture != picture2)
521 *picture = *picture2;
525 /* we begin to correct av delay at this threshold */
526 #define AV_DELAY_MAX 0.100
529 /* Expects img to be yuv420 */
530 static void fill_pad_region(AVPicture* img, int height, int width,
531 int padtop, int padbottom, int padleft, int padright, int *color) {
536 for (i = 0; i < 3; i++) {
537 shift = (i == 0) ? 0 : 1;
539 if (padtop || padleft) {
540 memset(img->data[i], color[i], (((img->linesize[i] * padtop) +
544 if (padleft || padright) {
545 optr = img->data[i] + (img->linesize[i] * (padtop >> shift)) +
546 (img->linesize[i] - (padright >> shift));
548 for (y = 0; y < ((height - (padtop + padbottom)) >> shift); y++) {
549 memset(optr, color[i], (padleft + padright) >> shift);
550 optr += img->linesize[i];
555 optr = img->data[i] + (img->linesize[i] * ((height - padbottom) >> shift));
556 memset(optr, color[i], ((img->linesize[i] * padbottom) >> shift));
562 static void do_video_out(AVFormatContext *s,
566 int *frame_size, AVOutputStream *audio_sync)
568 int nb_frames, i, ret;
569 AVFrame *final_picture, *formatted_picture;
570 AVFrame picture_format_temp, picture_crop_temp;
571 static uint8_t *video_buffer= NULL;
572 uint8_t *buf = NULL, *buf1 = NULL;
573 AVCodecContext *enc, *dec;
574 enum PixelFormat target_pixfmt;
576 #define VIDEO_BUFFER_SIZE (1024*1024)
578 avcodec_get_frame_defaults(&picture_format_temp);
579 avcodec_get_frame_defaults(&picture_crop_temp);
581 enc = &ost->st->codec;
582 dec = &ist->st->codec;
584 /* by default, we output a single frame */
589 /* NOTE: the A/V sync is always done by considering the audio is
590 the master clock. It is suffisant for transcoding or playing,
591 but not for the general case */
594 /* compute the A-V delay and duplicate/remove frames if needed */
595 double adelta, vdelta, av_delay;
597 adelta = audio_sync->sync_ipts - ((double)audio_sync->sync_opts *
598 audio_sync->st->time_base.num / audio_sync->st->time_base.den);
600 vdelta = ost->sync_ipts - ((double)ost->sync_opts *
601 ost->st->time_base.num / ost->st->time_base.den);
603 av_delay = adelta - vdelta;
604 if (av_delay < -AV_DELAY_MAX)
606 else if (av_delay > AV_DELAY_MAX)
608 // printf("adelta=%f vdelta=%f delay=%f nb=%d (A)\n", adelta, vdelta, av_delay, nb_frames);
612 vdelta = (double)(ost->st->pts.val) * ost->st->time_base.num / ost->st->time_base.den - (ost->sync_ipts - ost->sync_ipts_offset);
613 if (vdelta < 100 && vdelta > -100 && ost->sync_ipts_offset) {
614 if (vdelta < -AV_DELAY_MAX)
616 else if (vdelta > AV_DELAY_MAX)
619 ost->sync_ipts_offset -= vdelta;
620 if (!ost->sync_ipts_offset)
621 ost->sync_ipts_offset = 0.000001; /* one microsecond */
623 // printf("delay=%f nb=%d (V)\n",vdelta, nb_frames);
627 #if defined(AVSYNC_DEBUG)
629 static char *action[] = { "drop frame", "copy frame", "dup frame" };
630 if (audio_sync && verbose >=0) {
631 fprintf(stderr, "Input APTS %12.6f, output APTS %12.6f, ",
632 (double) audio_sync->sync_ipts,
633 (double) audio_sync->st->pts.val * st->time_base.num / st->time_base.den);
634 fprintf(stderr, "Input VPTS %12.6f, output VPTS %12.6f: %s\n",
635 (double) ost->sync_ipts,
636 (double) ost->st->pts.val * st->time_base.num / st->time_base.den,
646 video_buffer = av_malloc(VIDEO_BUFFER_SIZE);
650 /* convert pixel format if needed */
651 target_pixfmt = ost->video_resample || ost->video_pad
652 ? PIX_FMT_YUV420P : enc->pix_fmt;
653 if (dec->pix_fmt != target_pixfmt) {
656 /* create temporary picture */
657 size = avpicture_get_size(target_pixfmt, dec->width, dec->height);
658 buf = av_malloc(size);
661 formatted_picture = &picture_format_temp;
662 avpicture_fill((AVPicture*)formatted_picture, buf, target_pixfmt, dec->width, dec->height);
664 if (img_convert((AVPicture*)formatted_picture, target_pixfmt,
665 (AVPicture *)in_picture, dec->pix_fmt,
666 dec->width, dec->height) < 0) {
669 fprintf(stderr, "pixel format conversion not handled\n");
674 formatted_picture = in_picture;
677 /* XXX: resampling could be done before raw format conversion in
678 some cases to go faster */
679 /* XXX: only works for YUV420P */
680 if (ost->video_resample) {
681 final_picture = &ost->pict_tmp;
682 img_resample(ost->img_resample_ctx, (AVPicture*)final_picture, (AVPicture*)formatted_picture);
684 if (ost->padtop || ost->padbottom || ost->padleft || ost->padright) {
685 fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
686 ost->padtop, ost->padbottom, ost->padleft, ost->padright,
690 if (enc->pix_fmt != PIX_FMT_YUV420P) {
694 /* create temporary picture */
695 size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
696 buf = av_malloc(size);
699 final_picture = &picture_format_temp;
700 avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
702 if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
703 (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
704 enc->width, enc->height) < 0) {
707 fprintf(stderr, "pixel format conversion not handled\n");
712 } else if (ost->video_crop) {
713 picture_crop_temp.data[0] = formatted_picture->data[0] +
714 (ost->topBand * formatted_picture->linesize[0]) + ost->leftBand;
716 picture_crop_temp.data[1] = formatted_picture->data[1] +
717 ((ost->topBand >> 1) * formatted_picture->linesize[1]) +
718 (ost->leftBand >> 1);
720 picture_crop_temp.data[2] = formatted_picture->data[2] +
721 ((ost->topBand >> 1) * formatted_picture->linesize[2]) +
722 (ost->leftBand >> 1);
724 picture_crop_temp.linesize[0] = formatted_picture->linesize[0];
725 picture_crop_temp.linesize[1] = formatted_picture->linesize[1];
726 picture_crop_temp.linesize[2] = formatted_picture->linesize[2];
727 final_picture = &picture_crop_temp;
728 } else if (ost->video_pad) {
729 final_picture = &ost->pict_tmp;
731 for (i = 0; i < 3; i++) {
732 uint8_t *optr, *iptr;
733 int shift = (i == 0) ? 0 : 1;
736 /* set offset to start writing image into */
737 optr = final_picture->data[i] + (((final_picture->linesize[i] *
738 ost->padtop) + ost->padleft) >> shift);
739 iptr = formatted_picture->data[i];
741 yheight = (enc->height - ost->padtop - ost->padbottom) >> shift;
742 for (y = 0; y < yheight; y++) {
743 /* copy unpadded image row into padded image row */
744 memcpy(optr, iptr, formatted_picture->linesize[i]);
745 optr += final_picture->linesize[i];
746 iptr += formatted_picture->linesize[i];
750 fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
751 ost->padtop, ost->padbottom, ost->padleft, ost->padright,
754 if (enc->pix_fmt != PIX_FMT_YUV420P) {
758 /* create temporary picture */
759 size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
760 buf = av_malloc(size);
763 final_picture = &picture_format_temp;
764 avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
766 if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
767 (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
768 enc->width, enc->height) < 0) {
771 fprintf(stderr, "pixel format conversion not handled\n");
777 final_picture = formatted_picture;
779 /* duplicates frame if needed */
780 /* XXX: pb because no interleaving */
781 for(i=0;i<nb_frames;i++) {
782 if (s->oformat->flags & AVFMT_RAWPICTURE) {
783 /* raw pictures are written as AVPicture structure to
784 avoid any copies. We support temorarily the older
786 AVFrame* old_frame = enc->coded_frame;
787 enc->coded_frame = dec->coded_frame;
788 av_write_frame(s, ost->index,
789 (uint8_t *)final_picture, sizeof(AVPicture));
790 enc->coded_frame = old_frame;
794 big_picture= *final_picture;
795 /* better than nothing: use input picture interlaced
797 big_picture.interlaced_frame = in_picture->interlaced_frame;
798 if(do_interlace_me || do_interlace_dct){
799 if(top_field_first == -1)
800 big_picture.top_field_first = in_picture->top_field_first;
802 big_picture.top_field_first = 1;
805 /* handles sameq here. This is not correct because it may
806 not be a global option */
808 big_picture.quality = ist->st->quality;
810 big_picture.quality = ost->st->quality;
812 big_picture.pict_type = 0;
813 big_picture.pts = AV_NOPTS_VALUE; //FIXME
814 ret = avcodec_encode_video(enc,
815 video_buffer, VIDEO_BUFFER_SIZE,
817 //enc->frame_number = enc->real_pict_num;
818 av_write_frame(s, ost->index, video_buffer, ret);
820 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
821 // enc->frame_number-1, enc->real_pict_num, ret,
823 /* if two pass, output log */
824 if (ost->logfile && enc->stats_out) {
825 fprintf(ost->logfile, "%s", enc->stats_out);
835 static double psnr(double d){
836 if(d==0) return INFINITY;
837 return -10.0*log(d)/log(10.0);
840 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
843 static FILE *fvstats=NULL;
850 double ti1, bitrate, avg_bitrate;
854 today = localtime(&today2);
855 sprintf(filename, "vstats_%02d%02d%02d.log", today->tm_hour,
858 fvstats = fopen(filename,"w");
866 enc = &ost->st->codec;
867 if (enc->codec_type == CODEC_TYPE_VIDEO) {
868 frame_number = ost->frame_number;
869 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
870 if (enc->flags&CODEC_FLAG_PSNR)
871 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
873 fprintf(fvstats,"f_size= %6d ", frame_size);
874 /* compute pts value */
875 ti1 = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
879 bitrate = (double)(frame_size * 8) * enc->frame_rate / enc->frame_rate_base / 1000.0;
880 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
881 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
882 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
883 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
887 static void print_report(AVFormatContext **output_files,
888 AVOutputStream **ost_table, int nb_ostreams,
893 AVFormatContext *oc, *os;
896 int frame_number, vid, i;
897 double bitrate, ti1, pts;
898 static int64_t last_time = -1;
900 if (!is_last_report) {
902 /* display the report every 0.5 seconds */
903 cur_time = av_gettime();
904 if (last_time == -1) {
905 last_time = cur_time;
908 if ((cur_time - last_time) < 500000)
910 last_time = cur_time;
914 oc = output_files[0];
916 total_size = url_ftell(&oc->pb);
921 for(i=0;i<nb_ostreams;i++) {
923 os = output_files[ost->file_index];
924 enc = &ost->st->codec;
925 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
926 sprintf(buf + strlen(buf), "q=%2.1f ",
927 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
929 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
930 frame_number = ost->frame_number;
931 sprintf(buf + strlen(buf), "frame=%5d q=%2.1f ",
932 frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : 0);
934 sprintf(buf + strlen(buf), "L");
935 if (enc->flags&CODEC_FLAG_PSNR){
937 double error, error_sum=0;
938 double scale, scale_sum=0;
939 char type[3]= {'Y','U','V'};
940 sprintf(buf + strlen(buf), "PSNR=");
943 error= enc->error[j];
944 scale= enc->width*enc->height*255.0*255.0*frame_number;
946 error= enc->coded_frame->error[j];
947 scale= enc->width*enc->height*255.0*255.0;
952 sprintf(buf + strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
954 sprintf(buf + strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
958 /* compute min output value */
959 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
960 if ((pts < ti1) && (pts > 0))
966 if (verbose || is_last_report) {
967 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
969 sprintf(buf + strlen(buf),
970 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
971 (double)total_size / 1024, ti1, bitrate);
974 fprintf(stderr, "%s \r", buf);
979 if (is_last_report && verbose >= 0){
980 int64_t raw= audio_size + video_size + extra_size;
981 fprintf(stderr, "\n");
982 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
986 100.0*(total_size - raw)/raw
991 /* pkt = NULL means EOF (needed to flush decoder buffers) */
992 static int output_packet(AVInputStream *ist, int ist_index,
993 AVOutputStream **ost_table, int nb_ostreams,
1001 int data_size, got_picture;
1003 short samples[AVCODEC_MAX_AUDIO_FRAME_SIZE / 2];
1004 void *buffer_to_free;
1006 if (pkt && pkt->pts != AV_NOPTS_VALUE) {
1007 ist->next_pts = ist->pts = pkt->pts;
1009 ist->pts = ist->next_pts;
1023 /* decode the packet if needed */
1024 data_buf = NULL; /* fail safe */
1026 if (ist->decoding_needed) {
1027 switch(ist->st->codec.codec_type) {
1028 case CODEC_TYPE_AUDIO:
1029 /* XXX: could avoid copy if PCM 16 bits with same
1030 endianness as CPU */
1031 ret = avcodec_decode_audio(&ist->st->codec, samples, &data_size,
1037 /* Some bug in mpeg audio decoder gives */
1038 /* data_size < 0, it seems they are overflows */
1039 if (data_size <= 0) {
1040 /* no audio frame */
1043 data_buf = (uint8_t *)samples;
1044 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1045 (ist->st->codec.sample_rate * ist->st->codec.channels);
1047 case CODEC_TYPE_VIDEO:
1048 data_size = (ist->st->codec.width * ist->st->codec.height * 3) / 2;
1049 /* XXX: allocate picture correctly */
1050 avcodec_get_frame_defaults(&picture);
1052 ret = avcodec_decode_video(&ist->st->codec,
1053 &picture, &got_picture, ptr, len);
1054 ist->st->quality= picture.quality;
1058 /* no picture yet */
1059 goto discard_packet;
1061 if (ist->st->codec.frame_rate_base != 0) {
1062 ist->next_pts += ((int64_t)AV_TIME_BASE *
1063 ist->st->codec.frame_rate_base) /
1064 ist->st->codec.frame_rate;
1078 buffer_to_free = NULL;
1079 if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO) {
1080 pre_process_video_frame(ist, (AVPicture *)&picture,
1084 /* frame rate emulation */
1085 if (ist->st->codec.rate_emu) {
1086 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec.frame_rate_base, 1000000, ist->st->codec.frame_rate);
1087 int64_t now = av_gettime() - ist->start;
1095 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1096 is the one of the next displayed one */
1097 /* XXX: add mpeg4 too ? */
1098 if (ist->st->codec.codec_id == CODEC_ID_MPEG1VIDEO) {
1099 if (ist->st->codec.pict_type != B_TYPE) {
1101 tmp = ist->last_ip_pts;
1102 ist->last_ip_pts = ist->frac_pts.val;
1103 ist->frac_pts.val = tmp;
1107 /* if output time reached then transcode raw format,
1108 encode packets and output them */
1109 if (start_time == 0 || ist->pts >= start_time)
1110 for(i=0;i<nb_ostreams;i++) {
1114 if (ost->source_index == ist_index) {
1115 os = output_files[ost->file_index];
1118 printf("%d: got pts=%0.3f %0.3f\n", i,
1119 (double)pkt->pts / AV_TIME_BASE,
1120 ((double)ist->pts / AV_TIME_BASE) -
1121 ((double)ost->st->pts.val * ost->time_base.num / ost->time_base.den));
1123 /* set the input output pts pairs */
1124 ost->sync_ipts = (double)ist->pts / AV_TIME_BASE;
1125 /* XXX: take into account the various fifos,
1126 in particular for audio */
1127 ost->sync_opts = ost->st->pts.val;
1128 //printf("ipts=%lld sync_ipts=%f sync_opts=%lld pts.val=%lld pkt->pts=%lld\n", ist->pts, ost->sync_ipts, ost->sync_opts, ost->st->pts.val, pkt->pts);
1130 if (ost->encoding_needed) {
1131 switch(ost->st->codec.codec_type) {
1132 case CODEC_TYPE_AUDIO:
1133 do_audio_out(os, ost, ist, data_buf, data_size);
1135 case CODEC_TYPE_VIDEO:
1136 /* find an audio stream for synchro */
1139 AVOutputStream *audio_sync, *ost1;
1141 for(i=0;i<nb_ostreams;i++) {
1142 ost1 = ost_table[i];
1143 if (ost1->file_index == ost->file_index &&
1144 ost1->st->codec.codec_type == CODEC_TYPE_AUDIO) {
1150 do_video_out(os, ost, ist, &picture, &frame_size, audio_sync);
1151 video_size += frame_size;
1152 if (do_vstats && frame_size)
1153 do_video_stats(os, ost, frame_size);
1162 /* no reencoding needed : output the packet directly */
1163 /* force the input stream PTS */
1165 avcodec_get_frame_defaults(&avframe);
1166 ost->st->codec.coded_frame= &avframe;
1167 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1168 ost->st->pts.val= av_rescale(ist->pts, ost->st->time_base.den, ost->st->time_base.num*AV_TIME_BASE);
1170 if(ost->st->codec.codec_type == CODEC_TYPE_AUDIO)
1171 audio_size += data_size;
1172 else if (ost->st->codec.codec_type == CODEC_TYPE_VIDEO)
1173 video_size += data_size;
1175 av_write_frame(os, ost->index, data_buf, data_size);
1176 ost->st->codec.frame_number++;
1177 ost->frame_number++;
1181 av_free(buffer_to_free);
1191 * The following code is the main loop of the file converter
1193 static int av_encode(AVFormatContext **output_files,
1194 int nb_output_files,
1195 AVFormatContext **input_files,
1197 AVStreamMap *stream_maps, int nb_stream_maps)
1199 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1200 AVFormatContext *is, *os;
1201 AVCodecContext *codec, *icodec;
1202 AVOutputStream *ost, **ost_table = NULL;
1203 AVInputStream *ist, **ist_table = NULL;
1204 AVInputFile *file_table;
1205 AVFormatContext *stream_no_data;
1208 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1212 /* input stream init */
1214 for(i=0;i<nb_input_files;i++) {
1215 is = input_files[i];
1216 file_table[i].ist_index = j;
1217 file_table[i].nb_streams = is->nb_streams;
1218 j += is->nb_streams;
1222 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1226 for(i=0;i<nb_istreams;i++) {
1227 ist = av_mallocz(sizeof(AVInputStream));
1233 for(i=0;i<nb_input_files;i++) {
1234 is = input_files[i];
1235 for(k=0;k<is->nb_streams;k++) {
1236 ist = ist_table[j++];
1237 ist->st = is->streams[k];
1238 ist->file_index = i;
1240 ist->discard = 1; /* the stream is discarded by default
1243 if (ist->st->codec.rate_emu) {
1244 ist->start = av_gettime();
1250 /* output stream init */
1252 for(i=0;i<nb_output_files;i++) {
1253 os = output_files[i];
1254 nb_ostreams += os->nb_streams;
1256 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1257 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1261 /* Sanity check the mapping args -- do the input files & streams exist? */
1262 for(i=0;i<nb_stream_maps;i++) {
1263 int fi = stream_maps[i].file_index;
1264 int si = stream_maps[i].stream_index;
1266 if (fi < 0 || fi > nb_input_files - 1 ||
1267 si < 0 || si > file_table[fi].nb_streams - 1) {
1268 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1273 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1276 for(i=0;i<nb_ostreams;i++) {
1277 ost = av_mallocz(sizeof(AVOutputStream));
1284 for(k=0;k<nb_output_files;k++) {
1285 os = output_files[k];
1286 for(i=0;i<os->nb_streams;i++) {
1288 ost = ost_table[n++];
1289 ost->file_index = k;
1291 ost->st = os->streams[i];
1292 if (nb_stream_maps > 0) {
1293 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1294 stream_maps[n-1].stream_index;
1296 /* Sanity check that the stream types match */
1297 if (ist_table[ost->source_index]->st->codec.codec_type != ost->st->codec.codec_type) {
1298 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1299 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1300 ost->file_index, ost->index);
1305 /* get corresponding input stream index : we select the first one with the right type */
1307 for(j=0;j<nb_istreams;j++) {
1310 ist->st->codec.codec_type == ost->st->codec.codec_type) {
1311 ost->source_index = j;
1317 /* try again and reuse existing stream */
1318 for(j=0;j<nb_istreams;j++) {
1320 if (ist->st->codec.codec_type == ost->st->codec.codec_type) {
1321 ost->source_index = j;
1326 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1327 ost->file_index, ost->index);
1332 ist = ist_table[ost->source_index];
1337 /* for each output stream, we compute the right encoding parameters */
1338 for(i=0;i<nb_ostreams;i++) {
1340 ist = ist_table[ost->source_index];
1342 codec = &ost->st->codec;
1343 icodec = &ist->st->codec;
1345 if (ost->st->stream_copy) {
1346 /* if stream_copy is selected, no need to decode or encode */
1347 codec->codec_id = icodec->codec_id;
1348 codec->codec_type = icodec->codec_type;
1349 codec->codec_tag = icodec->codec_tag;
1350 codec->bit_rate = icodec->bit_rate;
1351 switch(codec->codec_type) {
1352 case CODEC_TYPE_AUDIO:
1353 codec->sample_rate = icodec->sample_rate;
1354 codec->channels = icodec->channels;
1355 codec->frame_size = icodec->frame_size;
1357 case CODEC_TYPE_VIDEO:
1358 codec->frame_rate = icodec->frame_rate;
1359 codec->frame_rate_base = icodec->frame_rate_base;
1360 codec->width = icodec->width;
1361 codec->height = icodec->height;
1367 switch(codec->codec_type) {
1368 case CODEC_TYPE_AUDIO:
1369 if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1372 if (codec->channels == icodec->channels &&
1373 codec->sample_rate == icodec->sample_rate) {
1374 ost->audio_resample = 0;
1376 if (codec->channels != icodec->channels &&
1377 icodec->codec_id == CODEC_ID_AC3) {
1378 /* Special case for 5:1 AC3 input */
1379 /* and mono or stereo output */
1380 /* Request specific number of channels */
1381 icodec->channels = codec->channels;
1382 if (codec->sample_rate == icodec->sample_rate)
1383 ost->audio_resample = 0;
1385 ost->audio_resample = 1;
1386 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1388 icodec->sample_rate);
1391 printf("Can't resample. Aborting.\n");
1395 /* Request specific number of channels */
1396 icodec->channels = codec->channels;
1398 ost->audio_resample = 1;
1399 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1401 icodec->sample_rate);
1404 printf("Can't resample. Aborting.\n");
1409 ist->decoding_needed = 1;
1410 ost->encoding_needed = 1;
1412 case CODEC_TYPE_VIDEO:
1413 if (codec->width == icodec->width &&
1414 codec->height == icodec->height &&
1415 frame_topBand == 0 &&
1416 frame_bottomBand == 0 &&
1417 frame_leftBand == 0 &&
1418 frame_rightBand == 0 &&
1419 frame_padtop == 0 &&
1420 frame_padbottom == 0 &&
1421 frame_padleft == 0 &&
1422 frame_padright == 0)
1424 ost->video_resample = 0;
1425 ost->video_crop = 0;
1427 } else if ((codec->width == icodec->width -
1428 (frame_leftBand + frame_rightBand)) &&
1429 (codec->height == icodec->height -
1430 (frame_topBand + frame_bottomBand)))
1432 ost->video_resample = 0;
1433 ost->video_crop = 1;
1434 ost->topBand = frame_topBand;
1435 ost->leftBand = frame_leftBand;
1436 } else if ((codec->width == icodec->width +
1437 (frame_padleft + frame_padright)) &&
1438 (codec->height == icodec->height +
1439 (frame_padtop + frame_padbottom))) {
1440 ost->video_resample = 0;
1441 ost->video_crop = 0;
1443 ost->padtop = frame_padtop;
1444 ost->padleft = frame_padleft;
1445 ost->padbottom = frame_padbottom;
1446 ost->padright = frame_padright;
1447 avcodec_get_frame_defaults(&ost->pict_tmp);
1448 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1449 codec->width, codec->height ) )
1452 ost->video_resample = 1;
1453 ost->video_crop = 0; // cropping is handled as part of resample
1454 avcodec_get_frame_defaults(&ost->pict_tmp);
1455 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1456 codec->width, codec->height ) )
1459 ost->img_resample_ctx = img_resample_full_init(
1460 ost->st->codec.width, ost->st->codec.height,
1461 ist->st->codec.width, ist->st->codec.height,
1462 frame_topBand, frame_bottomBand,
1463 frame_leftBand, frame_rightBand,
1464 frame_padtop, frame_padbottom,
1465 frame_padleft, frame_padright);
1467 ost->padtop = frame_padtop;
1468 ost->padleft = frame_padleft;
1469 ost->padbottom = frame_padbottom;
1470 ost->padright = frame_padright;
1473 ost->encoding_needed = 1;
1474 ist->decoding_needed = 1;
1480 if (ost->encoding_needed &&
1481 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1482 char logfilename[1024];
1487 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1489 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1490 if (codec->flags & CODEC_FLAG_PASS1) {
1491 f = fopen(logfilename, "w");
1493 perror(logfilename);
1498 /* read the log file */
1499 f = fopen(logfilename, "r");
1501 perror(logfilename);
1504 fseek(f, 0, SEEK_END);
1506 fseek(f, 0, SEEK_SET);
1507 logbuffer = av_malloc(size + 1);
1509 fprintf(stderr, "Could not allocate log buffer\n");
1512 size = fread(logbuffer, 1, size, f);
1514 logbuffer[size] = '\0';
1515 codec->stats_in = logbuffer;
1521 /* dump the file output parameters - cannot be done before in case
1523 for(i=0;i<nb_output_files;i++) {
1524 dump_format(output_files[i], i, output_files[i]->filename, 1);
1527 /* dump the stream mapping */
1529 fprintf(stderr, "Stream mapping:\n");
1530 for(i=0;i<nb_ostreams;i++) {
1532 fprintf(stderr, " Stream #%d.%d -> #%d.%d\n",
1533 ist_table[ost->source_index]->file_index,
1534 ist_table[ost->source_index]->index,
1540 /* open each encoder */
1541 for(i=0;i<nb_ostreams;i++) {
1543 if (ost->encoding_needed) {
1545 codec = avcodec_find_encoder(ost->st->codec.codec_id);
1547 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1548 ost->file_index, ost->index);
1551 if (avcodec_open(&ost->st->codec, codec) < 0) {
1552 fprintf(stderr, "Error while opening codec for stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1553 ost->file_index, ost->index);
1556 extra_size += ost->st->codec.extradata_size;
1560 /* open each decoder */
1561 for(i=0;i<nb_istreams;i++) {
1563 if (ist->decoding_needed) {
1565 codec = avcodec_find_decoder(ist->st->codec.codec_id);
1567 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1568 ist->st->codec.codec_id, ist->file_index, ist->index);
1571 if (avcodec_open(&ist->st->codec, codec) < 0) {
1572 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1573 ist->file_index, ist->index);
1576 //if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO)
1577 // ist->st->codec.flags |= CODEC_FLAG_REPEAT_FIELD;
1582 for(i=0;i<nb_istreams;i++) {
1584 is = input_files[ist->file_index];
1589 /* compute buffer size max (should use a complete heuristic) */
1590 for(i=0;i<nb_input_files;i++) {
1591 file_table[i].buffer_size_max = 2048;
1594 /* open files and write file headers */
1595 for(i=0;i<nb_output_files;i++) {
1596 os = output_files[i];
1597 if (av_write_header(os) < 0) {
1598 fprintf(stderr, "Could not write header for output file #%d (incorrect codec paramters ?)\n", i);
1604 #ifndef CONFIG_WIN32
1605 if ( !using_stdin && verbose >= 0) {
1606 fprintf(stderr, "Press [q] to stop encoding\n");
1607 url_set_interrupt_cb(decode_interrupt_cb);
1615 for(; received_sigterm == 0;) {
1616 int file_index, ist_index;
1621 /* if 'q' pressed, exits */
1625 /* read_key() returns 0 on EOF */
1631 /* select the stream that we must read now by looking at the
1632 smallest output pts */
1635 for(i=0;i<nb_ostreams;i++) {
1638 os = output_files[ost->file_index];
1639 ist = ist_table[ost->source_index];
1640 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1641 if (!file_table[ist->file_index].eof_reached &&
1644 file_index = ist->file_index;
1647 /* if none, if is finished */
1648 if (file_index < 0) {
1652 /* finish if recording time exhausted */
1653 if (recording_time > 0 && pts_min >= (recording_time / 1000000.0))
1656 /* read a frame from it and output it in the fifo */
1657 is = input_files[file_index];
1658 if (av_read_frame(is, &pkt) < 0) {
1659 file_table[file_index].eof_reached = 1;
1664 stream_no_data = is;
1669 av_pkt_dump(stdout, &pkt, do_hex_dump);
1671 /* the following test is needed in case new streams appear
1672 dynamically in stream : we ignore them */
1673 if (pkt.stream_index >= file_table[file_index].nb_streams)
1674 goto discard_packet;
1675 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1676 ist = ist_table[ist_index];
1678 goto discard_packet;
1680 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1681 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1684 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1685 ist->file_index, ist->index);
1687 av_free_packet(&pkt);
1692 av_free_packet(&pkt);
1694 /* dump report by using the output first video and audio streams */
1695 print_report(output_files, ost_table, nb_ostreams, 0);
1698 /* at the end of stream, we must flush the decoder buffers */
1699 for(i=0;i<nb_istreams;i++) {
1701 if (ist->decoding_needed) {
1702 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1708 /* write the trailer if needed and close file */
1709 for(i=0;i<nb_output_files;i++) {
1710 os = output_files[i];
1711 av_write_trailer(os);
1714 /* dump report by using the first video and audio streams */
1715 print_report(output_files, ost_table, nb_ostreams, 1);
1717 /* close each encoder */
1718 for(i=0;i<nb_ostreams;i++) {
1720 if (ost->encoding_needed) {
1721 av_freep(&ost->st->codec.stats_in);
1722 avcodec_close(&ost->st->codec);
1726 /* close each decoder */
1727 for(i=0;i<nb_istreams;i++) {
1729 if (ist->decoding_needed) {
1730 avcodec_close(&ist->st->codec);
1738 av_free(file_table);
1741 for(i=0;i<nb_istreams;i++) {
1748 for(i=0;i<nb_ostreams;i++) {
1752 fclose(ost->logfile);
1753 ost->logfile = NULL;
1755 fifo_free(&ost->fifo); /* works even if fifo is not
1756 initialized but set to zero */
1757 av_free(ost->pict_tmp.data[0]);
1758 if (ost->video_resample)
1759 img_resample_close(ost->img_resample_ctx);
1760 if (ost->audio_resample)
1761 audio_resample_close(ost->resample);
1774 int file_read(const char *filename)
1777 unsigned char buffer[1024];
1780 if (url_open(&h, filename, O_RDONLY) < 0) {
1781 printf("could not open '%s'\n", filename);
1785 len = url_read(h, buffer, sizeof(buffer));
1788 for(i=0;i<len;i++) putchar(buffer[i]);
1795 static void opt_image_format(const char *arg)
1799 for(f = first_image_format; f != NULL; f = f->next) {
1800 if (!strcmp(arg, f->name))
1804 fprintf(stderr, "Unknown image format: '%s'\n", arg);
1810 static void opt_format(const char *arg)
1812 /* compatibility stuff for pgmyuv */
1813 if (!strcmp(arg, "pgmyuv")) {
1814 opt_image_format(arg);
1818 file_iformat = av_find_input_format(arg);
1819 file_oformat = guess_format(arg, NULL, NULL);
1820 if (!file_iformat && !file_oformat) {
1821 fprintf(stderr, "Unknown input or output format: %s\n", arg);
1826 static void opt_video_bitrate(const char *arg)
1828 video_bit_rate = atoi(arg) * 1000;
1831 static void opt_video_bitrate_tolerance(const char *arg)
1833 video_bit_rate_tolerance = atoi(arg) * 1000;
1836 static void opt_video_bitrate_max(const char *arg)
1838 video_rc_max_rate = atoi(arg) * 1000;
1841 static void opt_video_bitrate_min(const char *arg)
1843 video_rc_min_rate = atoi(arg) * 1000;
1846 static void opt_video_buffer_size(const char *arg)
1848 video_rc_buffer_size = atoi(arg) * 8*1024;
1851 static void opt_video_rc_eq(char *arg)
1856 static void opt_video_rc_override_string(char *arg)
1858 video_rc_override_string = arg;
1862 static void opt_workaround_bugs(const char *arg)
1864 workaround_bugs = atoi(arg);
1867 static void opt_dct_algo(const char *arg)
1869 dct_algo = atoi(arg);
1872 static void opt_idct_algo(const char *arg)
1874 idct_algo = atoi(arg);
1877 static void opt_me_threshold(const char *arg)
1879 me_threshold = atoi(arg);
1882 static void opt_mb_threshold(const char *arg)
1884 mb_threshold = atoi(arg);
1887 static void opt_error_resilience(const char *arg)
1889 error_resilience = atoi(arg);
1892 static void opt_error_concealment(const char *arg)
1894 error_concealment = atoi(arg);
1897 static void opt_debug(const char *arg)
1902 static void opt_vismv(const char *arg)
1904 debug_mv = atoi(arg);
1907 static void opt_verbose(const char *arg)
1909 verbose = atoi(arg);
1910 av_log_set_level(atoi(arg));
1913 static void opt_sync_method(const char *arg)
1915 sync_method = atoi(arg);
1918 static void opt_frame_rate(const char *arg)
1920 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
1921 fprintf(stderr, "Incorrect frame rate\n");
1926 static void opt_frame_crop_top(const char *arg)
1928 frame_topBand = atoi(arg);
1929 if (frame_topBand < 0) {
1930 fprintf(stderr, "Incorrect top crop size\n");
1933 if ((frame_topBand % 2) != 0) {
1934 fprintf(stderr, "Top crop size must be a multiple of 2\n");
1937 if ((frame_topBand) >= frame_height){
1938 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
1941 frame_height -= frame_topBand;
1944 static void opt_frame_crop_bottom(const char *arg)
1946 frame_bottomBand = atoi(arg);
1947 if (frame_bottomBand < 0) {
1948 fprintf(stderr, "Incorrect bottom crop size\n");
1951 if ((frame_bottomBand % 2) != 0) {
1952 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
1955 if ((frame_bottomBand) >= frame_height){
1956 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
1959 frame_height -= frame_bottomBand;
1962 static void opt_frame_crop_left(const char *arg)
1964 frame_leftBand = atoi(arg);
1965 if (frame_leftBand < 0) {
1966 fprintf(stderr, "Incorrect left crop size\n");
1969 if ((frame_leftBand % 2) != 0) {
1970 fprintf(stderr, "Left crop size must be a multiple of 2\n");
1973 if ((frame_leftBand) >= frame_width){
1974 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
1977 frame_width -= frame_leftBand;
1980 static void opt_frame_crop_right(const char *arg)
1982 frame_rightBand = atoi(arg);
1983 if (frame_rightBand < 0) {
1984 fprintf(stderr, "Incorrect right crop size\n");
1987 if ((frame_rightBand % 2) != 0) {
1988 fprintf(stderr, "Right crop size must be a multiple of 2\n");
1991 if ((frame_rightBand) >= frame_width){
1992 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
1995 frame_width -= frame_rightBand;
1998 static void opt_frame_size(const char *arg)
2000 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2001 fprintf(stderr, "Incorrect frame size\n");
2004 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2005 fprintf(stderr, "Frame size must be a multiple of 2\n");
2011 #define SCALEBITS 10
2012 #define ONE_HALF (1 << (SCALEBITS - 1))
2013 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2015 #define RGB_TO_Y(r, g, b) \
2016 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2017 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2019 #define RGB_TO_U(r1, g1, b1, shift)\
2020 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2021 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2023 #define RGB_TO_V(r1, g1, b1, shift)\
2024 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2025 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2027 static void opt_pad_color(const char *arg) {
2028 /* Input is expected to be six hex digits similar to
2029 how colors are expressed in html tags (but without the #) */
2030 int rgb = strtol(arg, NULL, 16);
2034 g = ((rgb >> 8) & 255);
2037 padcolor[0] = RGB_TO_Y(r,g,b);
2038 padcolor[1] = RGB_TO_U(r,g,b,0);
2039 padcolor[2] = RGB_TO_V(r,g,b,0);
2042 static void opt_frame_pad_top(const char *arg)
2044 frame_padtop = atoi(arg);
2045 if (frame_padtop < 0) {
2046 fprintf(stderr, "Incorrect top pad size\n");
2049 if ((frame_padtop % 2) != 0) {
2050 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2055 static void opt_frame_pad_bottom(const char *arg)
2057 frame_padbottom = atoi(arg);
2058 if (frame_padbottom < 0) {
2059 fprintf(stderr, "Incorrect bottom pad size\n");
2062 if ((frame_padbottom % 2) != 0) {
2063 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2069 static void opt_frame_pad_left(const char *arg)
2071 frame_padleft = atoi(arg);
2072 if (frame_padleft < 0) {
2073 fprintf(stderr, "Incorrect left pad size\n");
2076 if ((frame_padleft % 2) != 0) {
2077 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2083 static void opt_frame_pad_right(const char *arg)
2085 frame_padright = atoi(arg);
2086 if (frame_padright < 0) {
2087 fprintf(stderr, "Incorrect right pad size\n");
2090 if ((frame_padright % 2) != 0) {
2091 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2097 static void opt_frame_pix_fmt(const char *arg)
2099 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2102 static void opt_frame_aspect_ratio(const char *arg)
2108 p = strchr(arg, ':');
2110 x = strtol(arg, (char **)&arg, 10);
2112 y = strtol(arg+1, (char **)&arg, 10);
2114 ar = (double)x / (double)y;
2116 ar = strtod(arg, (char **)&arg);
2119 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2122 frame_aspect_ratio = ar;
2125 static void opt_gop_size(const char *arg)
2127 gop_size = atoi(arg);
2130 static void opt_b_frames(const char *arg)
2132 b_frames = atoi(arg);
2133 if (b_frames > FF_MAX_B_FRAMES) {
2134 fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2136 } else if (b_frames < 1) {
2137 fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2142 static void opt_mb_decision(const char *arg)
2144 mb_decision = atoi(arg);
2147 static void opt_mb_cmp(const char *arg)
2152 static void opt_ildct_cmp(const char *arg)
2154 ildct_cmp = atoi(arg);
2157 static void opt_sub_cmp(const char *arg)
2159 sub_cmp = atoi(arg);
2162 static void opt_cmp(const char *arg)
2167 static void opt_pre_cmp(const char *arg)
2169 pre_cmp = atoi(arg);
2172 static void opt_pre_me(const char *arg)
2177 static void opt_lumi_mask(const char *arg)
2179 lumi_mask = atof(arg);
2182 static void opt_dark_mask(const char *arg)
2184 dark_mask = atof(arg);
2187 static void opt_scplx_mask(const char *arg)
2189 scplx_mask = atof(arg);
2192 static void opt_tcplx_mask(const char *arg)
2194 tcplx_mask = atof(arg);
2197 static void opt_p_mask(const char *arg)
2202 static void opt_qscale(const char *arg)
2204 video_qscale = atof(arg);
2205 if (video_qscale < 0.01 ||
2206 video_qscale > 255) {
2207 fprintf(stderr, "qscale must be >= 0.01 and <= 255\n");
2212 static void opt_lmax(const char *arg)
2214 video_lmax = atof(arg)*FF_QP2LAMBDA;
2217 static void opt_lmin(const char *arg)
2219 video_lmin = atof(arg)*FF_QP2LAMBDA;
2222 static void opt_qmin(const char *arg)
2224 video_qmin = atoi(arg);
2225 if (video_qmin < 0 ||
2227 fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2232 static void opt_qmax(const char *arg)
2234 video_qmax = atoi(arg);
2235 if (video_qmax < 0 ||
2237 fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2242 static void opt_mb_qmin(const char *arg)
2244 video_mb_qmin = atoi(arg);
2245 if (video_mb_qmin < 0 ||
2246 video_mb_qmin > 31) {
2247 fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2252 static void opt_mb_qmax(const char *arg)
2254 video_mb_qmax = atoi(arg);
2255 if (video_mb_qmax < 0 ||
2256 video_mb_qmax > 31) {
2257 fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2262 static void opt_qdiff(const char *arg)
2264 video_qdiff = atoi(arg);
2265 if (video_qdiff < 0 ||
2267 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2272 static void opt_qblur(const char *arg)
2274 video_qblur = atof(arg);
2277 static void opt_qcomp(const char *arg)
2279 video_qcomp = atof(arg);
2282 static void opt_rc_initial_cplx(const char *arg)
2284 video_rc_initial_cplx = atof(arg);
2286 static void opt_b_qfactor(const char *arg)
2288 video_b_qfactor = atof(arg);
2290 static void opt_i_qfactor(const char *arg)
2292 video_i_qfactor = atof(arg);
2294 static void opt_b_qoffset(const char *arg)
2296 video_b_qoffset = atof(arg);
2298 static void opt_i_qoffset(const char *arg)
2300 video_i_qoffset = atof(arg);
2303 static void opt_ibias(const char *arg)
2305 video_intra_quant_bias = atoi(arg);
2307 static void opt_pbias(const char *arg)
2309 video_inter_quant_bias = atoi(arg);
2312 static void opt_packet_size(const char *arg)
2314 packet_size= atoi(arg);
2317 static void opt_error_rate(const char *arg)
2319 error_rate= atoi(arg);
2322 static void opt_strict(const char *arg)
2327 static void opt_top_field_first(const char *arg)
2329 top_field_first= atoi(arg);
2332 static void opt_noise_reduction(const char *arg)
2334 noise_reduction= atoi(arg);
2337 static void opt_qns(const char *arg)
2342 static void opt_sc_threshold(const char *arg)
2344 sc_threshold= atoi(arg);
2347 static void opt_me_range(const char *arg)
2349 me_range = atoi(arg);
2352 static void opt_thread_count(const char *arg)
2354 thread_count= atoi(arg);
2355 #if !defined(HAVE_PTHREADS) && !defined(HAVE_W32THREADS)
2357 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2361 static void opt_audio_bitrate(const char *arg)
2363 audio_bit_rate = atoi(arg) * 1000;
2366 static void opt_audio_rate(const char *arg)
2368 audio_sample_rate = atoi(arg);
2371 static void opt_audio_channels(const char *arg)
2373 audio_channels = atoi(arg);
2376 static void opt_video_device(const char *arg)
2378 video_device = av_strdup(arg);
2381 static void opt_video_channel(const char *arg)
2383 video_channel = strtol(arg, NULL, 0);
2386 static void opt_video_standard(const char *arg)
2388 video_standard = av_strdup(arg);
2391 static void opt_audio_device(const char *arg)
2393 audio_device = av_strdup(arg);
2396 static void opt_dv1394(const char *arg)
2398 video_grab_format = "dv1394";
2399 audio_grab_format = NULL;
2402 static void opt_audio_codec(const char *arg)
2406 if (!strcmp(arg, "copy")) {
2407 audio_stream_copy = 1;
2411 if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_AUDIO)
2416 fprintf(stderr, "Unknown audio codec '%s'\n", arg);
2419 audio_codec_id = p->id;
2424 static void add_frame_hooker(const char *arg)
2429 char *args = av_strdup(arg);
2433 argv[0] = strtok(args, " ");
2434 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2437 i = frame_hook_add(argc, argv);
2440 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2445 const char *motion_str[] = {
2455 static void opt_motion_estimation(const char *arg)
2461 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2464 if (!strcmp(*p, arg))
2468 me_method = (p - motion_str) + 1;
2471 static void opt_video_codec(const char *arg)
2475 if (!strcmp(arg, "copy")) {
2476 video_stream_copy = 1;
2480 if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_VIDEO)
2485 fprintf(stderr, "Unknown video codec '%s'\n", arg);
2488 video_codec_id = p->id;
2493 static void opt_map(const char *arg)
2499 m = &stream_maps[nb_stream_maps++];
2501 m->file_index = strtol(arg, (char **)&p, 0);
2505 m->stream_index = strtol(p, (char **)&p, 0);
2508 static void opt_recording_time(const char *arg)
2510 recording_time = parse_date(arg, 1);
2513 static void opt_start_time(const char *arg)
2515 start_time = parse_date(arg, 1);
2518 static void opt_rec_timestamp(const char *arg)
2520 rec_timestamp = parse_date(arg, 0) / 1000000;
2523 static void opt_input_file(const char *filename)
2525 AVFormatContext *ic;
2526 AVFormatParameters params, *ap = ¶ms;
2527 int err, i, ret, rfps, rfps_base;
2529 if (!strcmp(filename, "-"))
2532 using_stdin |= !strcmp(filename, "pipe:" ) ||
2533 !strcmp( filename, "/dev/stdin" );
2535 /* get default parameters from command line */
2536 memset(ap, 0, sizeof(*ap));
2537 ap->sample_rate = audio_sample_rate;
2538 ap->channels = audio_channels;
2539 ap->frame_rate = frame_rate;
2540 ap->frame_rate_base = frame_rate_base;
2541 ap->width = frame_width + frame_padleft + frame_padright;
2542 ap->height = frame_height + frame_padtop + frame_padbottom;
2543 ap->image_format = image_format;
2544 ap->pix_fmt = frame_pix_fmt;
2546 /* open the input file with generic libav function */
2547 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2549 print_error(filename, err);
2553 /* If not enough info to get the stream parameters, we decode the
2554 first frames to get it. (used in mpeg case for example) */
2555 ret = av_find_stream_info(ic);
2556 if (ret < 0 && verbose >= 0) {
2557 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2561 /* if seeking requested, we execute it */
2562 if (start_time != 0) {
2565 timestamp = start_time;
2566 /* add the stream start time */
2567 if (ic->start_time != AV_NOPTS_VALUE)
2568 timestamp += ic->start_time;
2569 ret = av_seek_frame(ic, -1, timestamp);
2571 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2572 filename, (double)timestamp / AV_TIME_BASE);
2574 /* reset seek info */
2578 /* update the current parameters so that they match the one of the input stream */
2579 for(i=0;i<ic->nb_streams;i++) {
2580 AVCodecContext *enc = &ic->streams[i]->codec;
2581 #if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
2583 avcodec_thread_init(enc, thread_count);
2585 enc->thread_count= thread_count;
2586 switch(enc->codec_type) {
2587 case CODEC_TYPE_AUDIO:
2588 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2589 audio_channels = enc->channels;
2590 audio_sample_rate = enc->sample_rate;
2592 case CODEC_TYPE_VIDEO:
2593 frame_height = enc->height;
2594 frame_width = enc->width;
2595 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2596 frame_pix_fmt = enc->pix_fmt;
2597 rfps = ic->streams[i]->r_frame_rate;
2598 rfps_base = ic->streams[i]->r_frame_rate_base;
2599 enc->workaround_bugs = workaround_bugs;
2600 enc->error_resilience = error_resilience;
2601 enc->error_concealment = error_concealment;
2602 enc->idct_algo = idct_algo;
2604 enc->debug_mv = debug_mv;
2606 enc->flags|= CODEC_FLAG_BITEXACT;
2608 enc->debug |= FF_DEBUG_MV;
2610 assert(enc->frame_rate_base == rfps_base); // should be true for now
2611 if (enc->frame_rate != rfps) {
2614 fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f->%2.2f\n",
2615 i, (float)enc->frame_rate / enc->frame_rate_base,
2617 (float)rfps / rfps_base);
2619 /* update the current frame rate to match the stream frame rate */
2621 frame_rate_base = rfps_base;
2623 enc->rate_emu = rate_emu;
2625 case CODEC_TYPE_DATA:
2632 input_files[nb_input_files] = ic;
2633 /* dump the file content */
2635 dump_format(ic, nb_input_files, filename, 0);
2638 file_iformat = NULL;
2639 file_oformat = NULL;
2640 image_format = NULL;
2645 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2647 int has_video, has_audio, i, j;
2648 AVFormatContext *ic;
2652 for(j=0;j<nb_input_files;j++) {
2653 ic = input_files[j];
2654 for(i=0;i<ic->nb_streams;i++) {
2655 AVCodecContext *enc = &ic->streams[i]->codec;
2656 switch(enc->codec_type) {
2657 case CODEC_TYPE_AUDIO:
2660 case CODEC_TYPE_VIDEO:
2663 case CODEC_TYPE_DATA:
2670 *has_video_ptr = has_video;
2671 *has_audio_ptr = has_audio;
2674 static void opt_output_file(const char *filename)
2677 AVFormatContext *oc;
2678 int use_video, use_audio, nb_streams, input_has_video, input_has_audio;
2680 AVFormatParameters params, *ap = ¶ms;
2682 if (!strcmp(filename, "-"))
2685 oc = av_alloc_format_context();
2687 if (!file_oformat) {
2688 file_oformat = guess_format(NULL, filename, NULL);
2689 if (!file_oformat) {
2690 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
2696 oc->oformat = file_oformat;
2698 if (!strcmp(file_oformat->name, "ffm") &&
2699 strstart(filename, "http:", NULL)) {
2700 /* special case for files sent to ffserver: we get the stream
2701 parameters from ffserver */
2702 if (read_ffserver_streams(oc, filename) < 0) {
2703 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
2707 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy;
2708 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy;
2710 /* disable if no corresponding type found and at least one
2712 if (nb_input_files > 0) {
2713 check_audio_video_inputs(&input_has_video, &input_has_audio);
2714 if (!input_has_video)
2716 if (!input_has_audio)
2720 /* manual disable */
2721 if (audio_disable) {
2724 if (video_disable) {
2730 AVCodecContext *video_enc;
2732 st = av_new_stream(oc, nb_streams++);
2734 fprintf(stderr, "Could not alloc stream\n");
2737 #if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
2739 avcodec_thread_init(&st->codec, thread_count);
2742 video_enc = &st->codec;
2744 if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
2745 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2746 if (video_stream_copy) {
2747 st->stream_copy = 1;
2748 video_enc->codec_type = CODEC_TYPE_VIDEO;
2754 codec_id = file_oformat->video_codec;
2755 if (video_codec_id != CODEC_ID_NONE)
2756 codec_id = video_codec_id;
2758 video_enc->codec_id = codec_id;
2759 codec = avcodec_find_encoder(codec_id);
2761 video_enc->bit_rate = video_bit_rate;
2762 video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
2763 video_enc->frame_rate = frame_rate;
2764 video_enc->frame_rate_base = frame_rate_base;
2765 if(codec && codec->supported_framerates){
2766 const AVRational *p= codec->supported_framerates;
2767 AVRational req= (AVRational){frame_rate, frame_rate_base};
2768 const AVRational *best=NULL;
2769 AVRational best_error= (AVRational){INT_MAX, 1};
2770 for(; p->den!=0; p++){
2771 AVRational error= av_sub_q(req, *p);
2772 if(error.num <0) error.num *= -1;
2773 if(av_cmp_q(error, best_error) < 0){
2778 video_enc->frame_rate = best->num;
2779 video_enc->frame_rate_base= best->den;
2782 video_enc->width = frame_width + frame_padright + frame_padleft;
2783 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2784 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
2785 video_enc->pix_fmt = frame_pix_fmt;
2787 if(codec && codec->pix_fmts){
2788 const enum PixelFormat *p= codec->pix_fmts;
2790 if(*p == video_enc->pix_fmt)
2794 video_enc->pix_fmt = codec->pix_fmts[0];
2798 video_enc->gop_size = gop_size;
2800 video_enc->gop_size = 0;
2801 if (video_qscale || same_quality) {
2802 video_enc->flags |= CODEC_FLAG_QSCALE;
2803 st->quality = FF_QP2LAMBDA * video_qscale;
2807 video_enc->intra_matrix = intra_matrix;
2809 video_enc->inter_matrix = inter_matrix;
2812 video_enc->flags |= CODEC_FLAG_BITEXACT;
2814 video_enc->mb_decision = mb_decision;
2815 video_enc->mb_cmp = mb_cmp;
2816 video_enc->ildct_cmp = ildct_cmp;
2817 video_enc->me_sub_cmp = sub_cmp;
2818 video_enc->me_cmp = cmp;
2819 video_enc->me_pre_cmp = pre_cmp;
2820 video_enc->pre_me = pre_me;
2821 video_enc->lumi_masking = lumi_mask;
2822 video_enc->dark_masking = dark_mask;
2823 video_enc->spatial_cplx_masking = scplx_mask;
2824 video_enc->temporal_cplx_masking = tcplx_mask;
2825 video_enc->p_masking = p_mask;
2826 video_enc->quantizer_noise_shaping= qns;
2829 video_enc->flags |= CODEC_FLAG_H263P_UMV;
2832 video_enc->flags |= CODEC_FLAG_H263P_SLICE_STRUCT;
2835 video_enc->flags |= CODEC_FLAG_H263P_AIC;
2838 video_enc->flags |= CODEC_FLAG_H263P_AIV;
2841 video_enc->flags |= CODEC_FLAG_4MV;
2844 video_enc->flags |= CODEC_FLAG_OBMC;
2847 video_enc->flags |= CODEC_FLAG_LOOP_FILTER;
2851 video_enc->flags |= CODEC_FLAG_PART;
2854 video_enc->flags |= CODEC_FLAG_ALT_SCAN;
2857 video_enc->flags |= CODEC_FLAG_TRELLIS_QUANT;
2859 if (use_scan_offset) {
2860 video_enc->flags |= CODEC_FLAG_SVCD_SCAN_OFFSET;
2863 video_enc->flags |= CODEC_FLAG_CLOSED_GOP;
2866 video_enc->flags |= CODEC_FLAG_QPEL;
2869 video_enc->max_b_frames = b_frames;
2870 video_enc->b_frame_strategy = 0;
2871 video_enc->b_quant_factor = 2.0;
2873 if (do_interlace_dct) {
2874 video_enc->flags |= CODEC_FLAG_INTERLACED_DCT;
2876 if (do_interlace_me) {
2877 video_enc->flags |= CODEC_FLAG_INTERLACED_ME;
2879 video_enc->qmin = video_qmin;
2880 video_enc->qmax = video_qmax;
2881 video_enc->lmin = video_lmin;
2882 video_enc->lmax = video_lmax;
2883 video_enc->mb_qmin = video_mb_qmin;
2884 video_enc->mb_qmax = video_mb_qmax;
2885 video_enc->max_qdiff = video_qdiff;
2886 video_enc->qblur = video_qblur;
2887 video_enc->qcompress = video_qcomp;
2888 video_enc->rc_eq = video_rc_eq;
2889 video_enc->debug = debug;
2890 video_enc->debug_mv = debug_mv;
2891 video_enc->thread_count = thread_count;
2892 p= video_rc_override_string;
2895 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2897 fprintf(stderr, "error parsing rc_override\n");
2900 video_enc->rc_override=
2901 av_realloc(video_enc->rc_override,
2902 sizeof(RcOverride)*(i+1));
2903 video_enc->rc_override[i].start_frame= start;
2904 video_enc->rc_override[i].end_frame = end;
2906 video_enc->rc_override[i].qscale= q;
2907 video_enc->rc_override[i].quality_factor= 1.0;
2910 video_enc->rc_override[i].qscale= 0;
2911 video_enc->rc_override[i].quality_factor= -q/100.0;
2916 video_enc->rc_override_count=i;
2918 video_enc->rc_max_rate = video_rc_max_rate;
2919 video_enc->rc_min_rate = video_rc_min_rate;
2920 video_enc->rc_buffer_size = video_rc_buffer_size;
2921 video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
2922 video_enc->rc_initial_cplx= video_rc_initial_cplx;
2923 video_enc->i_quant_factor = video_i_qfactor;
2924 video_enc->b_quant_factor = video_b_qfactor;
2925 video_enc->i_quant_offset = video_i_qoffset;
2926 video_enc->b_quant_offset = video_b_qoffset;
2927 video_enc->intra_quant_bias = video_intra_quant_bias;
2928 video_enc->inter_quant_bias = video_inter_quant_bias;
2929 video_enc->dct_algo = dct_algo;
2930 video_enc->idct_algo = idct_algo;
2931 video_enc->me_threshold= me_threshold;
2932 video_enc->mb_threshold= mb_threshold;
2933 video_enc->intra_dc_precision= intra_dc_precision;
2934 video_enc->strict_std_compliance = strict;
2935 video_enc->error_rate = error_rate;
2936 video_enc->noise_reduction= noise_reduction;
2937 video_enc->scenechange_threshold= sc_threshold;
2938 video_enc->me_range = me_range;
2939 video_enc->coder_type= coder;
2940 video_enc->context_model= context;
2941 video_enc->prediction_method= predictor;
2944 video_enc->rtp_mode= 1;
2945 video_enc->rtp_payload_size= packet_size;
2949 video_enc->flags|= CODEC_FLAG_PSNR;
2951 video_enc->me_method = me_method;
2956 video_enc->flags |= CODEC_FLAG_PASS1;
2958 video_enc->flags |= CODEC_FLAG_PASS2;
2965 AVCodecContext *audio_enc;
2967 st = av_new_stream(oc, nb_streams++);
2969 fprintf(stderr, "Could not alloc stream\n");
2972 #if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
2974 avcodec_thread_init(&st->codec, thread_count);
2977 audio_enc = &st->codec;
2978 audio_enc->codec_type = CODEC_TYPE_AUDIO;
2980 if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
2981 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2982 if (audio_stream_copy) {
2983 st->stream_copy = 1;
2985 codec_id = file_oformat->audio_codec;
2986 if (audio_codec_id != CODEC_ID_NONE)
2987 codec_id = audio_codec_id;
2988 audio_enc->codec_id = codec_id;
2990 audio_enc->bit_rate = audio_bit_rate;
2991 audio_enc->sample_rate = audio_sample_rate;
2992 audio_enc->strict_std_compliance = strict;
2993 audio_enc->thread_count = thread_count;
2994 /* For audio codecs other than AC3 we limit */
2995 /* the number of coded channels to stereo */
2996 if (audio_channels > 2 && codec_id != CODEC_ID_AC3) {
2997 audio_enc->channels = 2;
2999 audio_enc->channels = audio_channels;
3003 oc->nb_streams = nb_streams;
3006 fprintf(stderr, "No audio or video streams available\n");
3010 oc->timestamp = rec_timestamp;
3013 pstrcpy(oc->title, sizeof(oc->title), str_title);
3015 pstrcpy(oc->author, sizeof(oc->author), str_author);
3017 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3019 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3022 output_files[nb_output_files++] = oc;
3024 strcpy(oc->filename, filename);
3026 /* check filename in case of an image number is expected */
3027 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3028 if (filename_number_test(oc->filename) < 0) {
3029 print_error(oc->filename, AVERROR_NUMEXPECTED);
3034 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3035 /* test if it already exists to avoid loosing precious files */
3036 if (!file_overwrite &&
3037 (strchr(filename, ':') == NULL ||
3038 strstart(filename, "file:", NULL))) {
3039 if (url_exist(filename)) {
3042 if ( !using_stdin ) {
3043 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3046 if (toupper(c) != 'Y') {
3047 fprintf(stderr, "Not overwriting - exiting\n");
3052 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3059 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3060 fprintf(stderr, "Could not open '%s'\n", filename);
3065 memset(ap, 0, sizeof(*ap));
3066 ap->image_format = image_format;
3067 if (av_set_parameters(oc, ap) < 0) {
3068 fprintf(stderr, "%s: Invalid encoding parameters\n",
3073 /* reset some options */
3074 file_oformat = NULL;
3075 file_iformat = NULL;
3076 image_format = NULL;
3079 audio_codec_id = CODEC_ID_NONE;
3080 video_codec_id = CODEC_ID_NONE;
3081 audio_stream_copy = 0;
3082 video_stream_copy = 0;
3085 /* prepare dummy protocols for grab */
3086 static void prepare_grab(void)
3088 int has_video, has_audio, i, j;
3089 AVFormatContext *oc;
3090 AVFormatContext *ic;
3091 AVFormatParameters vp1, *vp = &vp1;
3092 AVFormatParameters ap1, *ap = &ap1;
3094 /* see if audio/video inputs are needed */
3097 memset(ap, 0, sizeof(*ap));
3098 memset(vp, 0, sizeof(*vp));
3099 for(j=0;j<nb_output_files;j++) {
3100 oc = output_files[j];
3101 for(i=0;i<oc->nb_streams;i++) {
3102 AVCodecContext *enc = &oc->streams[i]->codec;
3103 switch(enc->codec_type) {
3104 case CODEC_TYPE_AUDIO:
3105 if (enc->sample_rate > ap->sample_rate)
3106 ap->sample_rate = enc->sample_rate;
3107 if (enc->channels > ap->channels)
3108 ap->channels = enc->channels;
3111 case CODEC_TYPE_VIDEO:
3112 if (enc->width > vp->width)
3113 vp->width = enc->width;
3114 if (enc->height > vp->height)
3115 vp->height = enc->height;
3117 assert(enc->frame_rate_base == DEFAULT_FRAME_RATE_BASE);
3118 if (enc->frame_rate > vp->frame_rate){
3119 vp->frame_rate = enc->frame_rate;
3120 vp->frame_rate_base = enc->frame_rate_base;
3130 if (has_video == 0 && has_audio == 0) {
3131 fprintf(stderr, "Output file must have at least one audio or video stream\n");
3136 AVInputFormat *fmt1;
3137 fmt1 = av_find_input_format(video_grab_format);
3138 vp->device = video_device;
3139 vp->channel = video_channel;
3140 vp->standard = video_standard;
3141 if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3142 fprintf(stderr, "Could not find video grab device\n");
3145 /* If not enough info to get the stream parameters, we decode the
3146 first frames to get it. */
3147 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3148 fprintf(stderr, "Could not find video grab parameters\n");
3151 /* by now video grab has one stream */
3152 ic->streams[0]->r_frame_rate = vp->frame_rate;
3153 ic->streams[0]->r_frame_rate_base = vp->frame_rate_base;
3154 input_files[nb_input_files] = ic;
3157 dump_format(ic, nb_input_files, "", 0);
3161 if (has_audio && audio_grab_format) {
3162 AVInputFormat *fmt1;
3163 fmt1 = av_find_input_format(audio_grab_format);
3164 ap->device = audio_device;
3165 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3166 fprintf(stderr, "Could not find audio grab device\n");
3169 input_files[nb_input_files] = ic;
3172 dump_format(ic, nb_input_files, "", 0);
3178 /* same option as mencoder */
3179 static void opt_pass(const char *pass_str)
3182 pass = atoi(pass_str);
3183 if (pass != 1 && pass != 2) {
3184 fprintf(stderr, "pass number can be only 1 or 2\n");
3190 #if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
3191 static int64_t getutime(void)
3193 return av_gettime();
3196 static int64_t getutime(void)
3198 struct rusage rusage;
3200 getrusage(RUSAGE_SELF, &rusage);
3201 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3205 extern int ffm_nopts;
3207 static void opt_bitexact(void)
3210 /* disable generate of real time pts in ffm (need to be supressed anyway) */
3214 static void show_formats(void)
3216 AVInputFormat *ifmt;
3217 AVOutputFormat *ofmt;
3218 AVImageFormat *image_fmt;
3221 const char **pp, *last_name;
3223 printf("File formats:\n");
3228 const char *name=NULL;
3230 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3231 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3232 strcmp(ofmt->name, last_name)>0){
3237 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3238 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3239 strcmp(ifmt->name, last_name)>0){
3243 if(name && strcmp(ifmt->name, name)==0)
3258 printf("Image formats:\n");
3259 for(image_fmt = first_image_format; image_fmt != NULL;
3260 image_fmt = image_fmt->next) {
3263 image_fmt->img_read ? "D":" ",
3264 image_fmt->img_write ? "E":" ",
3269 printf("Codecs:\n");
3277 for(p = first_avcodec; p != NULL; p = p->next) {
3278 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3279 strcmp(p->name, last_name)>0){
3281 decode= encode= cap=0;
3283 if(p2 && strcmp(p->name, p2->name)==0){
3284 if(p->decode) decode=1;
3285 if(p->encode) encode=1;
3286 cap |= p->capabilities;
3291 last_name= p2->name;
3295 decode ? "D": (/*p2->decoder ? "d":*/" "),
3297 p2->type == CODEC_TYPE_AUDIO ? "A":"V",
3298 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3299 cap & CODEC_CAP_DR1 ? "D":" ",
3300 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3302 /* if(p2->decoder && decode==0)
3303 printf(" use %s for decoding", p2->decoder->name);*/
3308 printf("Supported file protocols:\n");
3309 for(up = first_protocol; up != NULL; up = up->next)
3310 printf(" %s:", up->name);
3313 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3314 printf("Motion estimation methods:\n");
3318 if ((pp - motion_str + 1) == ME_ZERO)
3319 printf("(fastest)");
3320 else if ((pp - motion_str + 1) == ME_FULL)
3321 printf("(slowest)");
3322 else if ((pp - motion_str + 1) == ME_EPZS)
3323 printf("(default)");
3328 "Note, the names of encoders and decoders dont always match, so there are\n"
3329 "several cases where the above table shows encoder only or decoder only entries\n"
3330 "even though both encoding and decoding are supported for example, the h263\n"
3331 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3336 void parse_matrix_coeffs(uint16_t *dest, const char *str)
3339 const char *p = str;
3346 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3353 void opt_inter_matrix(const char *arg)
3355 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3356 parse_matrix_coeffs(inter_matrix, arg);
3359 void opt_intra_matrix(const char *arg)
3361 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3362 parse_matrix_coeffs(intra_matrix, arg);
3365 static void opt_target(const char *arg)
3369 if(!strncmp(arg, "pal-", 4)) {
3372 } else if(!strncmp(arg, "ntsc-", 5)) {
3377 /* Calculate FR via float to avoid int overflow */
3378 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3381 } else if((fr == 29970) || (fr == 23976)) {
3384 /* Try to determine PAL/NTSC by peeking in the input files */
3385 if(nb_input_files) {
3387 for(j = 0; j < nb_input_files; j++) {
3388 for(i = 0; i < input_files[j]->nb_streams; i++) {
3389 AVCodecContext *c = &input_files[j]->streams[i]->codec;
3390 if(c->codec_type != CODEC_TYPE_VIDEO)
3392 fr = c->frame_rate * 1000 / c->frame_rate_base;
3396 } else if((fr == 29970) || (fr == 23976)) {
3406 if(verbose && norm >= 0)
3407 printf("Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3411 fprintf(stderr, "Could not determine norm (PAL/NTSC) for target.\n");
3412 fprintf(stderr, "Please prefix target with \"pal-\" or \"ntsc-\",\n");
3413 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3417 if(!strcmp(arg, "vcd")) {
3419 opt_video_codec("mpeg1video");
3420 opt_audio_codec("mp2");
3423 opt_frame_size(norm ? "352x240" : "352x288");
3425 video_bit_rate = 1150000;
3426 video_rc_max_rate = 1150000;
3427 video_rc_min_rate = 1150000;
3428 video_rc_buffer_size = 40*1024*8;
3430 audio_bit_rate = 224000;
3431 audio_sample_rate = 44100;
3433 } else if(!strcmp(arg, "svcd")) {
3435 opt_video_codec("mpeg2video");
3436 opt_audio_codec("mp2");
3439 opt_frame_size(norm ? "480x480" : "480x576");
3440 opt_gop_size(norm ? "18" : "15");
3442 video_bit_rate = 2040000;
3443 video_rc_max_rate = 2516000;
3444 video_rc_min_rate = 0; //1145000;
3445 video_rc_buffer_size = 224*1024*8;
3446 use_scan_offset = 1;
3448 audio_bit_rate = 224000;
3449 audio_sample_rate = 44100;
3451 } else if(!strcmp(arg, "dvd")) {
3453 opt_video_codec("mpeg2video");
3454 opt_audio_codec("ac3");
3457 opt_frame_size(norm ? "720x480" : "720x576");
3458 opt_gop_size(norm ? "18" : "15");
3460 video_bit_rate = 6000000;
3461 video_rc_max_rate = 9000000;
3462 video_rc_min_rate = 0; //1500000;
3463 video_rc_buffer_size = 224*1024*8;
3465 audio_bit_rate = 448000;
3466 audio_sample_rate = 48000;
3469 fprintf(stderr, "Unknown target: %s\n", arg);
3474 static void show_version(void)
3476 printf("ffmpeg " FFMPEG_VERSION "\n"
3479 avcodec_build(), LIBAVFORMAT_BUILD);
3483 const OptionDef options[] = {
3485 { "L", 0, {(void*)show_license}, "show license" },
3486 { "h", 0, {(void*)show_help}, "show help" },
3487 { "version", 0, {(void*)show_version}, "show version" },
3488 { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3489 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3490 { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3491 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3492 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3493 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream" },
3494 { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3495 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3496 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3497 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3498 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3499 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3500 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3501 { "debug", HAS_ARG | OPT_EXPERT, {(void*)opt_debug}, "print specific debug info", "" },
3502 { "vismv", HAS_ARG | OPT_EXPERT, {(void*)opt_vismv}, "visualize motion vectors", "" },
3503 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3504 "add timings for benchmarking" },
3505 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3506 "dump each input packet" },
3507 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3508 "when dumping packets, also dump the payload" },
3509 { "bitexact", OPT_EXPERT, {(void*)opt_bitexact}, "only use bit exact algorithms (for codec testing)" },
3510 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3511 { "loop", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3512 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3513 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\" or \"dvd\")", "type" },
3514 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3515 { "sync", HAS_ARG | OPT_EXPERT, {(void*)opt_sync_method}, "sync method", "" },
3518 { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
3519 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3520 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3521 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3522 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3523 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3524 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3525 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3526 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3527 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3528 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3529 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3530 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3531 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3532 { "g", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
3533 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3534 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3535 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
3536 { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
3537 { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
3538 { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
3539 { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
3540 { "mbqmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_qmin}, "min macroblock quantiser scale (VBR)", "q" },
3541 { "mbqmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_qmax}, "max macroblock quantiser scale (VBR)", "q" },
3542 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
3543 { "qblur", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
3544 { "qcomp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
3545 { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
3546 { "b_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
3547 { "i_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
3548 { "b_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
3549 { "i_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
3550 { "ibias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ibias}, "intra quant bias", "bias" },
3551 { "pbias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pbias}, "inter quant bias", "bias" },
3552 // { "b_strategy", HAS_ARG | OPT_EXPERT, {(void*)opt_b_strategy}, "dynamic b frame selection strategy", "strategy" },
3553 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3554 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3555 { "bt", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
3556 { "maxrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
3557 { "minrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
3558 { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffere size (in kByte)", "size" },
3559 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3560 { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3562 { "dct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dct_algo}, "set dct algo", "algo" },
3563 { "idct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_idct_algo}, "set idct algo", "algo" },
3564 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
3565 { "mb_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_threshold}, "macroblock threshold", "" },
3566 { "er", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_resilience}, "set error resilience", "n" },
3567 { "ec", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_concealment}, "set error concealment", "bit_mask" },
3568 { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
3569 { "hq", OPT_BOOL, {(void*)&mb_decision}, "activate high quality settings" },
3570 { "mbd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_decision}, "macroblock decision", "mode" },
3571 { "mbcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_cmp}, "macroblock compare function", "cmp function" },
3572 { "ildctcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ildct_cmp}, "ildct compare function", "cmp function" },
3573 { "subcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sub_cmp}, "subpel compare function", "cmp function" },
3574 { "cmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_cmp}, "fullpel compare function", "cmp function" },
3575 { "precmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_cmp}, "pre motion estimation compare function", "cmp function" },
3576 { "preme", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_me}, "pre motion estimation", "" },
3577 { "lumi_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lumi_mask}, "luminance masking", "" },
3578 { "dark_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dark_mask}, "darkness masking", "" },
3579 { "scplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_scplx_mask}, "spatial complexity masking", "" },
3580 { "tcplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_tcplx_mask}, "teporal complexity masking", "" },
3581 { "p_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_p_mask}, "inter masking", "" },
3582 { "4mv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_4mv}, "use four motion vector by macroblock (MPEG4)" },
3583 { "obmc", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_obmc}, "use overlapped block motion compensation (h263+)" },
3584 { "lf", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_loop}, "use loop filter (h263+)" },
3585 { "part", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_part}, "use data partitioning (MPEG4)" },
3586 { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
3587 { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
3588 { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
3589 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3590 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3591 "use same video quality as source (implies VBR)" },
3592 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3593 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3594 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3595 "deinterlace pictures" },
3596 { "ildct", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_dct},
3597 "force interlaced dct support in encoder (MPEG2/MPEG4)" },
3598 { "ilme", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_me},
3599 "force interlaced me support in encoder (MPEG2/MPEG4)" },
3600 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3601 { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
3602 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3603 { "aic", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aic}, "enable Advanced intra coding (h263+)" },
3604 { "aiv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aiv}, "enable Alternative inter vlc (h263+)" },
3605 { "umv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_umv}, "enable Unlimited Motion Vector (h263+)" },
3606 { "ssm", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_ss}, "enable Slice Structured mode (h263+)" },
3607 { "alt", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_alt_scan}, "enable alternate scantable (MPEG2/MPEG4)" },
3608 { "trell", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_trell}, "enable trellis quantization" },
3609 { "cgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&closed_gop}, "closed gop" },
3610 { "scan_offset", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_scan_offset}, "enable SVCD Scan Offset placeholder" },
3611 { "qpel", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qpel}, "enable 1/4-pel" },
3612 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3613 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3614 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3615 { "nr", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_noise_reduction}, "noise reduction", "" },
3616 { "qns", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qns}, "quantization noise shaping", "" },
3617 { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
3618 { "me_range", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_range}, "limit motion vectors range (1023 for DivX player)", "range" },
3619 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3620 { "coder", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&coder}, "coder type", "" },
3621 { "context", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&context}, "context model", "" },
3622 { "pred", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&predictor}, "prediction method", "" },
3625 { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
3626 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3627 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3628 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3629 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3632 { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
3633 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3634 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3635 { "dv1394", OPT_EXPERT | OPT_GRAB, {(void*)opt_dv1394}, "set DV1394 grab", "" },
3636 { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
3640 static void show_banner(void)
3642 printf("ffmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2003 Fabrice Bellard\n");
3645 static void show_license(void)
3650 "This program is free software; you can redistribute it and/or modify\n"
3651 "it under the terms of the GNU General Public License as published by\n"
3652 "the Free Software Foundation; either version 2 of the License, or\n"
3653 "(at your option) any later version.\n"
3655 "This program is distributed in the hope that it will be useful,\n"
3656 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3657 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
3658 "GNU General Public License for more details.\n"
3660 "You should have received a copy of the GNU General Public License\n"
3661 "along with this program; if not, write to the Free Software\n"
3662 "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n"
3666 "This library is free software; you can redistribute it and/or\n"
3667 "modify it under the terms of the GNU Lesser General Public\n"
3668 "License as published by the Free Software Foundation; either\n"
3669 "version 2 of the License, or (at your option) any later version.\n"
3671 "This library is distributed in the hope that it will be useful,\n"
3672 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3673 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
3674 "Lesser General Public License for more details.\n"
3676 "You should have received a copy of the GNU Lesser General Public\n"
3677 "License along with this library; if not, write to the Free Software\n"
3678 "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n"
3684 static void show_help(void)
3687 printf("usage: ffmpeg [[options] -i input_file]... {[options] outfile}...\n"
3688 "Hyper fast Audio and Video encoder\n");
3690 show_help_options(options, "Main options:\n",
3691 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3692 show_help_options(options, "\nVideo options:\n",
3693 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3695 show_help_options(options, "\nAdvanced Video options:\n",
3696 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3697 OPT_VIDEO | OPT_EXPERT);
3698 show_help_options(options, "\nAudio options:\n",
3699 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3701 show_help_options(options, "\nAdvanced Audio options:\n",
3702 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3703 OPT_AUDIO | OPT_EXPERT);
3704 show_help_options(options, "\nAudio/Video grab options:\n",
3707 show_help_options(options, "\nAdvanced options:\n",
3708 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3713 void parse_arg_file(const char *filename)
3715 opt_output_file(filename);
3718 int main(int argc, char **argv)
3729 parse_options(argc, argv, options);
3731 /* file converter / grab */
3732 if (nb_output_files <= 0) {
3733 fprintf(stderr, "Must supply at least one output file\n");
3737 if (nb_input_files == 0) {
3742 av_encode(output_files, nb_output_files, input_files, nb_input_files,
3743 stream_maps, nb_stream_maps);
3744 ti = getutime() - ti;
3746 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3750 for(i=0;i<nb_output_files;i++) {
3751 /* maybe av_close_output_file ??? */
3752 AVFormatContext *s = output_files[i];
3754 if (!(s->oformat->flags & AVFMT_NOFILE))
3756 for(j=0;j<s->nb_streams;j++)
3757 av_free(s->streams[j]);
3760 for(i=0;i<nb_input_files;i++)
3761 av_close_input_file(input_files[i]);
3766 av_free(intra_matrix);
3768 av_free(inter_matrix);
3770 #ifdef POWERPC_PERFORMANCE_REPORT
3771 extern void powerpc_display_perf_report(void);
3772 powerpc_display_perf_report();
3773 #endif /* POWERPC_PERFORMANCE_REPORT */
3775 #ifndef CONFIG_WIN32
3776 if (received_sigterm) {
3778 "Received signal %d: terminating.\n",
3779 (int) received_sigterm);
3783 exit(0); /* not all OS-es handle main() return value */