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"
28 #include <sys/ioctl.h>
31 #include <sys/resource.h>
35 #include <sys/types.h>
36 #include <sys/select.h>
39 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
47 #if !defined(INFINITY) && defined(HUGE_VAL)
48 #define INFINITY HUGE_VAL
51 /* select an input stream for an output stream */
52 typedef struct AVStreamMap {
57 /** select an input file for an output file */
58 typedef struct AVMetaDataMap {
63 extern const OptionDef options[];
65 static void show_help(void);
66 static void show_license(void);
70 static AVFormatContext *input_files[MAX_FILES];
71 static int64_t input_files_ts_offset[MAX_FILES];
72 static int nb_input_files = 0;
74 static AVFormatContext *output_files[MAX_FILES];
75 static int nb_output_files = 0;
77 static AVStreamMap stream_maps[MAX_FILES];
78 static int nb_stream_maps;
80 static AVMetaDataMap meta_data_maps[MAX_FILES];
81 static int nb_meta_data_maps;
83 static AVInputFormat *file_iformat;
84 static AVOutputFormat *file_oformat;
85 static AVImageFormat *image_format;
86 static int frame_width = 160;
87 static int frame_height = 128;
88 static float frame_aspect_ratio = 0;
89 static enum PixelFormat frame_pix_fmt = PIX_FMT_YUV420P;
90 static int frame_padtop = 0;
91 static int frame_padbottom = 0;
92 static int frame_padleft = 0;
93 static int frame_padright = 0;
94 static int padcolor[3] = {16,128,128}; /* default to black */
95 static int frame_topBand = 0;
96 static int frame_bottomBand = 0;
97 static int frame_leftBand = 0;
98 static int frame_rightBand = 0;
99 static int max_frames[3] = {INT_MAX, INT_MAX, INT_MAX};
100 static int frame_rate = 25;
101 static int frame_rate_base = 1;
102 static int video_bit_rate = 200*1000;
103 static int video_bit_rate_tolerance = 4000*1000;
104 static float video_qscale = 0;
105 static int video_qmin = 2;
106 static int video_qmax = 31;
107 static int video_lmin = 2*FF_QP2LAMBDA;
108 static int video_lmax = 31*FF_QP2LAMBDA;
109 static int video_mb_qmin = 2;
110 static int video_mb_qmax = 31;
111 static int video_qdiff = 3;
112 static float video_qblur = 0.5;
113 static float video_qcomp = 0.5;
114 static uint16_t *intra_matrix = NULL;
115 static uint16_t *inter_matrix = NULL;
116 #if 0 //experimental, (can be removed)
117 static float video_rc_qsquish=1.0;
118 static float video_rc_qmod_amp=0;
119 static int video_rc_qmod_freq=0;
121 static char *video_rc_override_string=NULL;
122 static char *video_rc_eq="tex^qComp";
123 static int video_rc_buffer_size=0;
124 static float video_rc_buffer_aggressivity=1.0;
125 static int video_rc_max_rate=0;
126 static int video_rc_min_rate=0;
127 static float video_rc_initial_cplx=0;
128 static float video_b_qfactor = 1.25;
129 static float video_b_qoffset = 1.25;
130 static float video_i_qfactor = -0.8;
131 static float video_i_qoffset = 0.0;
132 static int video_intra_quant_bias= FF_DEFAULT_QUANT_BIAS;
133 static int video_inter_quant_bias= FF_DEFAULT_QUANT_BIAS;
134 static int me_method = ME_EPZS;
135 static int video_disable = 0;
136 static int video_codec_id = CODEC_ID_NONE;
137 static int video_codec_tag = 0;
138 static int same_quality = 0;
139 static int b_frames = 0;
140 static int mb_decision = FF_MB_DECISION_SIMPLE;
141 static int ildct_cmp = FF_CMP_VSAD;
142 static int mb_cmp = FF_CMP_SAD;
143 static int sub_cmp = FF_CMP_SAD;
144 static int cmp = FF_CMP_SAD;
145 static int pre_cmp = FF_CMP_SAD;
146 static int pre_me = 0;
147 static float lumi_mask = 0;
148 static float dark_mask = 0;
149 static float scplx_mask = 0;
150 static float tcplx_mask = 0;
151 static float p_mask = 0;
152 static int use_4mv = 0;
153 static int use_obmc = 0;
154 static int use_loop = 0;
155 static int use_aic = 0;
156 static int use_aiv = 0;
157 static int use_umv = 0;
158 static int use_ss = 0;
159 static int use_alt_scan = 0;
160 static int use_trell = 0;
161 static int use_scan_offset = 0;
162 static int use_qpel = 0;
163 static int use_qprd = 0;
164 static int use_cbprd = 0;
166 static int closed_gop = 0;
167 static int strict_gop = 0;
168 static int do_deinterlace = 0;
169 static int do_interlace_dct = 0;
170 static int do_interlace_me = 0;
171 static int workaround_bugs = FF_BUG_AUTODETECT;
172 static int error_resilience = 2;
173 static int error_concealment = 3;
174 static int dct_algo = 0;
175 static int idct_algo = 0;
176 static int use_part = 0;
177 static int packet_size = 0;
178 static int error_rate = 0;
179 static int strict = 0;
180 static int top_field_first = -1;
181 static int noise_reduction = 0;
182 static int sc_threshold = 0;
183 static int debug = 0;
184 static int debug_mv = 0;
185 static int me_threshold = 0;
186 static int mb_threshold = 0;
187 static int intra_dc_precision = 8;
188 static int coder = 0;
189 static int context = 0;
190 static int predictor = 0;
191 static int video_profile = FF_PROFILE_UNKNOWN;
192 static int video_level = FF_LEVEL_UNKNOWN;
193 static int nsse_weight = 8;
194 static int subpel_quality= 8;
195 static int lowres= 0;
196 static int frame_skip_threshold= 0;
197 static int frame_skip_factor= 0;
198 static int frame_skip_exp= 0;
199 static int frame_skip_cmp= FF_CMP_DCTMAX;
200 extern int loop_input; /* currently a hack */
202 static int gop_size = 12;
203 static int intra_only = 0;
204 static int audio_sample_rate = 44100;
205 static int audio_bit_rate = 64000;
206 static int audio_disable = 0;
207 static int audio_channels = 1;
208 static int audio_codec_id = CODEC_ID_NONE;
209 static int audio_codec_tag = 0;
211 static int mux_rate= 0;
212 static int mux_packet_size= 0;
213 static float mux_preload= 0.5;
214 static float mux_max_delay= 0.7;
216 static int64_t recording_time = 0;
217 static int64_t start_time = 0;
218 static int64_t rec_timestamp = 0;
219 static int64_t input_ts_offset = 0;
220 static int file_overwrite = 0;
221 static char *str_title = NULL;
222 static char *str_author = NULL;
223 static char *str_copyright = NULL;
224 static char *str_comment = NULL;
225 static int do_benchmark = 0;
226 static int do_hex_dump = 0;
227 static int do_pkt_dump = 0;
228 static int do_psnr = 0;
229 static int do_vstats = 0;
230 static int do_pass = 0;
231 static int bitexact = 0;
232 static char *pass_logfilename = NULL;
233 static int audio_stream_copy = 0;
234 static int video_stream_copy = 0;
235 static int video_sync_method= 1;
236 static int audio_sync_method= 0;
237 static int copy_ts= 0;
239 static int rate_emu = 0;
241 static char *video_grab_format = "video4linux";
242 static char *video_device = NULL;
243 static char *grab_device = NULL;
244 static int video_channel = 0;
245 static char *video_standard = "ntsc";
247 static char *audio_grab_format = "audio_device";
248 static char *audio_device = NULL;
250 static int using_stdin = 0;
251 static int using_vhook = 0;
252 static int verbose = 1;
253 static int thread_count= 1;
254 static int q_pressed = 0;
255 static int me_range = 0;
256 static int64_t video_size = 0;
257 static int64_t audio_size = 0;
258 static int64_t extra_size = 0;
259 static int nb_frames_dup = 0;
260 static int nb_frames_drop = 0;
261 static int input_sync;
263 static int pgmyuv_compatibility_hack=0;
266 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
268 typedef struct AVOutputStream {
269 int file_index; /* file index */
270 int index; /* stream index in the output file */
271 int source_index; /* AVInputStream index */
272 AVStream *st; /* stream in the output file */
273 int encoding_needed; /* true if encoding needed for this stream */
275 /* input pts and corresponding output pts
277 double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
278 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
280 int video_resample; /* video_resample and video_crop are mutually exclusive */
281 AVFrame pict_tmp; /* temporary image for resampling */
282 ImgReSampleContext *img_resample_ctx; /* for image resampling */
284 int video_crop; /* video_resample and video_crop are mutually exclusive */
285 int topBand; /* cropping area sizes */
288 int video_pad; /* video_resample and video_pad are mutually exclusive */
289 int padtop; /* padding area sizes */
296 ReSampleContext *resample; /* for audio resampling */
297 FifoBuffer fifo; /* for compression: one audio fifo per codec */
301 typedef struct AVInputStream {
305 int discard; /* true if stream data should be discarded */
306 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
307 int64_t sample_index; /* current sample */
309 int64_t start; /* time when read started */
310 unsigned long frame; /* current frame */
311 int64_t next_pts; /* synthetic pts for cases where pkt.pts
313 int64_t pts; /* current pts */
314 int is_start; /* is 1 at the start and after a discontinuity */
317 typedef struct AVInputFile {
318 int eof_reached; /* true if eof reached */
319 int ist_index; /* index of first stream in ist_table */
320 int buffer_size; /* current total buffer size */
321 int buffer_size_max; /* buffer size at which we consider we can stop
323 int nb_streams; /* nb streams we are aware of */
328 /* init terminal so that we can grab keys */
329 static struct termios oldtty;
331 static void term_exit(void)
333 tcsetattr (0, TCSANOW, &oldtty);
336 static volatile sig_atomic_t received_sigterm = 0;
339 sigterm_handler(int sig)
341 received_sigterm = sig;
345 static void term_init(void)
352 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
353 |INLCR|IGNCR|ICRNL|IXON);
354 tty.c_oflag |= OPOST;
355 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
356 tty.c_cflag &= ~(CSIZE|PARENB);
361 tcsetattr (0, TCSANOW, &tty);
363 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
364 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
365 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
367 register a function to be called at normal program termination
370 #ifdef CONFIG_BEOS_NETSERVER
371 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
375 /* read a key without blocking */
376 static int read_key(void)
380 #ifndef CONFIG_BEOS_NETSERVER
388 n = select(1, &rfds, NULL, NULL, &tv);
400 static int decode_interrupt_cb(void)
402 return q_pressed || (q_pressed = read_key() == 'q');
407 static volatile int received_sigterm = 0;
409 /* no interactive support */
410 static void term_exit(void)
414 static void term_init(void)
418 static int read_key(void)
425 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
430 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
433 /* copy stream format */
434 s->nb_streams = ic->nb_streams;
435 for(i=0;i<ic->nb_streams;i++) {
438 st = av_mallocz(sizeof(AVStream));
439 memcpy(st, ic->streams[i], sizeof(AVStream));
443 av_close_input_file(ic);
447 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
449 static void do_audio_out(AVFormatContext *s,
452 unsigned char *buf, int size)
455 static uint8_t *audio_buf = NULL;
456 static uint8_t *audio_out = NULL;
457 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
459 int size_out, frame_bytes, ret;
460 AVCodecContext *enc= &ost->st->codec;
462 /* SC: dynamic allocation of buffers */
464 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
466 audio_out = av_malloc(audio_out_size);
467 if (!audio_buf || !audio_out)
468 return; /* Should signal an error ! */
470 if(audio_sync_method){
471 double delta = ost->sync_ipts * enc->sample_rate - ost->sync_opts
472 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2);
473 double idelta= delta*ist->st->codec.sample_rate / enc->sample_rate;
474 int byte_delta= ((int)idelta)*2*ist->st->codec.channels;
476 //FIXME resample delay
477 if(fabs(delta) > 50){
480 byte_delta= FFMAX(byte_delta, -size);
484 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
489 static uint8_t *input_tmp= NULL;
490 input_tmp= av_realloc(input_tmp, byte_delta + size);
492 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
495 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
497 memset(input_tmp, 0, byte_delta);
498 memcpy(input_tmp + byte_delta, buf, size);
502 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
504 }else if(audio_sync_method>1){
505 int comp= clip(delta, -audio_sync_method, audio_sync_method);
506 assert(ost->audio_resample);
508 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
509 // fprintf(stderr, "drift:%f len:%d opts:%lld ipts:%lld fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(ost->sync_ipts * enc->sample_rate), fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2));
510 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
514 ost->sync_opts= lrintf(ost->sync_ipts * enc->sample_rate)
515 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2); //FIXME wrong
517 if (ost->audio_resample) {
519 size_out = audio_resample(ost->resample,
520 (short *)buftmp, (short *)buf,
521 size / (ist->st->codec.channels * 2));
522 size_out = size_out * enc->channels * 2;
528 /* now encode as many frames as possible */
529 if (enc->frame_size > 1) {
530 /* output resampled raw samples */
531 fifo_write(&ost->fifo, buftmp, size_out,
534 frame_bytes = enc->frame_size * 2 * enc->channels;
536 while (fifo_read(&ost->fifo, audio_buf, frame_bytes,
537 &ost->fifo.rptr) == 0) {
539 av_init_packet(&pkt);
541 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
544 pkt.stream_index= ost->index;
548 pkt.pts= enc->coded_frame->pts;
549 pkt.flags |= PKT_FLAG_KEY;
550 av_interleaved_write_frame(s, &pkt);
552 ost->sync_opts += enc->frame_size;
556 av_init_packet(&pkt);
558 ost->sync_opts += size_out / (2 * enc->channels);
560 /* output a pcm frame */
561 /* XXX: change encoding codec API to avoid this ? */
562 switch(enc->codec->id) {
563 case CODEC_ID_PCM_S16LE:
564 case CODEC_ID_PCM_S16BE:
565 case CODEC_ID_PCM_U16LE:
566 case CODEC_ID_PCM_U16BE:
569 size_out = size_out >> 1;
572 ret = avcodec_encode_audio(enc, audio_out, size_out,
575 pkt.stream_index= ost->index;
579 pkt.pts= enc->coded_frame->pts;
580 pkt.flags |= PKT_FLAG_KEY;
581 av_interleaved_write_frame(s, &pkt);
585 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
589 AVPicture picture_tmp;
592 dec = &ist->st->codec;
594 /* deinterlace : must be done before any resize */
595 if (do_deinterlace || using_vhook) {
598 /* create temporary picture */
599 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
600 buf = av_malloc(size);
604 picture2 = &picture_tmp;
605 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
608 if(avpicture_deinterlace(picture2, picture,
609 dec->pix_fmt, dec->width, dec->height) < 0) {
610 /* if error, do not deinterlace */
616 if (img_convert(picture2, dec->pix_fmt, picture,
617 dec->pix_fmt, dec->width, dec->height) < 0) {
618 /* if error, do not copy */
628 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
630 if (picture != picture2)
631 *picture = *picture2;
635 /* we begin to correct av delay at this threshold */
636 #define AV_DELAY_MAX 0.100
639 /* Expects img to be yuv420 */
640 static void fill_pad_region(AVPicture* img, int height, int width,
641 int padtop, int padbottom, int padleft, int padright, int *color) {
646 for (i = 0; i < 3; i++) {
647 shift = (i == 0) ? 0 : 1;
649 if (padtop || padleft) {
650 memset(img->data[i], color[i], (((img->linesize[i] * padtop) +
654 if (padleft || padright) {
655 optr = img->data[i] + (img->linesize[i] * (padtop >> shift)) +
656 (img->linesize[i] - (padright >> shift));
658 for (y = 0; y < ((height - (padtop + padbottom)) >> shift); y++) {
659 memset(optr, color[i], (padleft + padright) >> shift);
660 optr += img->linesize[i];
665 optr = img->data[i] + (img->linesize[i] * ((height - padbottom) >> shift));
666 memset(optr, color[i], ((img->linesize[i] * padbottom) >> shift));
671 static int bit_buffer_size= 1024*256;
672 static uint8_t *bit_buffer= NULL;
674 static void do_video_out(AVFormatContext *s,
680 int nb_frames, i, ret;
681 AVFrame *final_picture, *formatted_picture;
682 AVFrame picture_format_temp, picture_crop_temp;
683 uint8_t *buf = NULL, *buf1 = NULL;
684 AVCodecContext *enc, *dec;
685 enum PixelFormat target_pixfmt;
687 avcodec_get_frame_defaults(&picture_format_temp);
688 avcodec_get_frame_defaults(&picture_crop_temp);
690 enc = &ost->st->codec;
691 dec = &ist->st->codec;
693 /* by default, we output a single frame */
698 if(video_sync_method){
700 vdelta = ost->sync_ipts * enc->frame_rate / enc->frame_rate_base - ost->sync_opts;
701 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
704 else if (vdelta > 1.1)
705 nb_frames = lrintf(vdelta);
706 //fprintf(stderr, "vdelta:%f, ost->sync_opts:%lld, ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, ost->sync_ipts, nb_frames);
710 fprintf(stderr, "*** drop!\n");
711 }else if (nb_frames > 1) {
712 nb_frames_dup += nb_frames;
714 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
717 ost->sync_opts= lrintf(ost->sync_ipts * enc->frame_rate / enc->frame_rate_base);
719 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
723 /* convert pixel format if needed */
724 target_pixfmt = ost->video_resample || ost->video_pad
725 ? PIX_FMT_YUV420P : enc->pix_fmt;
726 if (dec->pix_fmt != target_pixfmt) {
729 /* create temporary picture */
730 size = avpicture_get_size(target_pixfmt, dec->width, dec->height);
731 buf = av_malloc(size);
734 formatted_picture = &picture_format_temp;
735 avpicture_fill((AVPicture*)formatted_picture, buf, target_pixfmt, dec->width, dec->height);
737 if (img_convert((AVPicture*)formatted_picture, target_pixfmt,
738 (AVPicture *)in_picture, dec->pix_fmt,
739 dec->width, dec->height) < 0) {
742 fprintf(stderr, "pixel format conversion not handled\n");
747 formatted_picture = in_picture;
750 /* XXX: resampling could be done before raw format conversion in
751 some cases to go faster */
752 /* XXX: only works for YUV420P */
753 if (ost->video_resample) {
754 final_picture = &ost->pict_tmp;
755 img_resample(ost->img_resample_ctx, (AVPicture*)final_picture, (AVPicture*)formatted_picture);
757 if (ost->padtop || ost->padbottom || ost->padleft || ost->padright) {
758 fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
759 ost->padtop, ost->padbottom, ost->padleft, ost->padright,
763 if (enc->pix_fmt != PIX_FMT_YUV420P) {
767 /* create temporary picture */
768 size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
769 buf = av_malloc(size);
772 final_picture = &picture_format_temp;
773 avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
775 if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
776 (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
777 enc->width, enc->height) < 0) {
780 fprintf(stderr, "pixel format conversion not handled\n");
785 } else if (ost->video_crop) {
786 picture_crop_temp.data[0] = formatted_picture->data[0] +
787 (ost->topBand * formatted_picture->linesize[0]) + ost->leftBand;
789 picture_crop_temp.data[1] = formatted_picture->data[1] +
790 ((ost->topBand >> 1) * formatted_picture->linesize[1]) +
791 (ost->leftBand >> 1);
793 picture_crop_temp.data[2] = formatted_picture->data[2] +
794 ((ost->topBand >> 1) * formatted_picture->linesize[2]) +
795 (ost->leftBand >> 1);
797 picture_crop_temp.linesize[0] = formatted_picture->linesize[0];
798 picture_crop_temp.linesize[1] = formatted_picture->linesize[1];
799 picture_crop_temp.linesize[2] = formatted_picture->linesize[2];
800 final_picture = &picture_crop_temp;
801 } else if (ost->video_pad) {
802 final_picture = &ost->pict_tmp;
804 for (i = 0; i < 3; i++) {
805 uint8_t *optr, *iptr;
806 int shift = (i == 0) ? 0 : 1;
809 /* set offset to start writing image into */
810 optr = final_picture->data[i] + (((final_picture->linesize[i] *
811 ost->padtop) + ost->padleft) >> shift);
812 iptr = formatted_picture->data[i];
814 yheight = (enc->height - ost->padtop - ost->padbottom) >> shift;
815 for (y = 0; y < yheight; y++) {
816 /* copy unpadded image row into padded image row */
817 memcpy(optr, iptr, formatted_picture->linesize[i]);
818 optr += final_picture->linesize[i];
819 iptr += formatted_picture->linesize[i];
823 fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
824 ost->padtop, ost->padbottom, ost->padleft, ost->padright,
827 if (enc->pix_fmt != PIX_FMT_YUV420P) {
831 /* create temporary picture */
832 size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
833 buf = av_malloc(size);
836 final_picture = &picture_format_temp;
837 avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
839 if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
840 (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
841 enc->width, enc->height) < 0) {
844 fprintf(stderr, "pixel format conversion not handled\n");
850 final_picture = formatted_picture;
852 /* duplicates frame if needed */
853 for(i=0;i<nb_frames;i++) {
855 av_init_packet(&pkt);
856 pkt.stream_index= ost->index;
858 if (s->oformat->flags & AVFMT_RAWPICTURE) {
859 /* raw pictures are written as AVPicture structure to
860 avoid any copies. We support temorarily the older
862 AVFrame* old_frame = enc->coded_frame;
863 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
864 pkt.data= (uint8_t *)final_picture;
865 pkt.size= sizeof(AVPicture);
867 pkt.pts= dec->coded_frame->pts;
868 if(dec->coded_frame && dec->coded_frame->key_frame)
869 pkt.flags |= PKT_FLAG_KEY;
871 av_interleaved_write_frame(s, &pkt);
872 enc->coded_frame = old_frame;
876 big_picture= *final_picture;
877 /* better than nothing: use input picture interlaced
879 big_picture.interlaced_frame = in_picture->interlaced_frame;
880 if(do_interlace_me || do_interlace_dct){
881 if(top_field_first == -1)
882 big_picture.top_field_first = in_picture->top_field_first;
884 big_picture.top_field_first = top_field_first;
887 /* handles sameq here. This is not correct because it may
888 not be a global option */
890 big_picture.quality = ist->st->quality;
892 big_picture.quality = ost->st->quality;
894 big_picture.pict_type = 0;
895 // big_picture.pts = AV_NOPTS_VALUE;
896 big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->frame_rate_base, enc->frame_rate);
897 //av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
898 ret = avcodec_encode_video(enc,
899 bit_buffer, bit_buffer_size,
901 //enc->frame_number = enc->real_pict_num;
903 pkt.data= bit_buffer;
906 pkt.pts= enc->coded_frame->pts;
907 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n",
908 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->frame_rate, AV_TIME_BASE*(int64_t)enc->frame_rate_base) : -1,
909 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->frame_rate, AV_TIME_BASE*(int64_t)enc->frame_rate_base) : -1);*/
911 if(enc->coded_frame && enc->coded_frame->key_frame)
912 pkt.flags |= PKT_FLAG_KEY;
913 av_interleaved_write_frame(s, &pkt);
915 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
916 // enc->frame_number-1, enc->real_pict_num, ret,
918 /* if two pass, output log */
919 if (ost->logfile && enc->stats_out) {
920 fprintf(ost->logfile, "%s", enc->stats_out);
932 static double psnr(double d){
933 if(d==0) return INFINITY;
934 return -10.0*log(d)/log(10.0);
937 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
940 static FILE *fvstats=NULL;
947 double ti1, bitrate, avg_bitrate;
951 today = localtime(&today2);
952 sprintf(filename, "vstats_%02d%02d%02d.log", today->tm_hour,
955 fvstats = fopen(filename,"w");
963 enc = &ost->st->codec;
964 if (enc->codec_type == CODEC_TYPE_VIDEO) {
965 frame_number = ost->frame_number;
966 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
967 if (enc->flags&CODEC_FLAG_PSNR)
968 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
970 fprintf(fvstats,"f_size= %6d ", frame_size);
971 /* compute pts value */
972 ti1 = (double)ost->sync_opts *enc->frame_rate_base / enc->frame_rate;
976 bitrate = (double)(frame_size * 8) * enc->frame_rate / enc->frame_rate_base / 1000.0;
977 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
978 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
979 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
980 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
984 static void print_report(AVFormatContext **output_files,
985 AVOutputStream **ost_table, int nb_ostreams,
990 AVFormatContext *oc, *os;
993 int frame_number, vid, i;
994 double bitrate, ti1, pts;
995 static int64_t last_time = -1;
997 if (!is_last_report) {
999 /* display the report every 0.5 seconds */
1000 cur_time = av_gettime();
1001 if (last_time == -1) {
1002 last_time = cur_time;
1005 if ((cur_time - last_time) < 500000)
1007 last_time = cur_time;
1011 oc = output_files[0];
1013 total_size = url_ftell(&oc->pb);
1018 for(i=0;i<nb_ostreams;i++) {
1020 os = output_files[ost->file_index];
1021 enc = &ost->st->codec;
1022 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1023 sprintf(buf + strlen(buf), "q=%2.1f ",
1024 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1026 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1027 frame_number = ost->frame_number;
1028 sprintf(buf + strlen(buf), "frame=%5d q=%2.1f ",
1029 frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : 0);
1031 sprintf(buf + strlen(buf), "L");
1032 if (enc->flags&CODEC_FLAG_PSNR){
1034 double error, error_sum=0;
1035 double scale, scale_sum=0;
1036 char type[3]= {'Y','U','V'};
1037 sprintf(buf + strlen(buf), "PSNR=");
1040 error= enc->error[j];
1041 scale= enc->width*enc->height*255.0*255.0*frame_number;
1043 error= enc->coded_frame->error[j];
1044 scale= enc->width*enc->height*255.0*255.0;
1049 sprintf(buf + strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1051 sprintf(buf + strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1055 /* compute min output value */
1056 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1057 if ((pts < ti1) && (pts > 0))
1063 if (verbose || is_last_report) {
1064 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1066 sprintf(buf + strlen(buf),
1067 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1068 (double)total_size / 1024, ti1, bitrate);
1071 sprintf(buf + strlen(buf), " dup=%d drop=%d",
1072 nb_frames_dup, nb_frames_drop);
1075 fprintf(stderr, "%s \r", buf);
1080 if (is_last_report && verbose >= 0){
1081 int64_t raw= audio_size + video_size + extra_size;
1082 fprintf(stderr, "\n");
1083 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1087 100.0*(total_size - raw)/raw
1092 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1093 static int output_packet(AVInputStream *ist, int ist_index,
1094 AVOutputStream **ost_table, int nb_ostreams,
1095 const AVPacket *pkt)
1097 AVFormatContext *os;
1098 AVOutputStream *ost;
1102 int data_size, got_picture;
1104 void *buffer_to_free;
1105 static int samples_size= 0;
1106 static short *samples= NULL;
1109 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1110 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1111 ist->next_pts = ist->pts = pkt->dts;
1113 assert(ist->pts == ist->next_pts);
1127 /* decode the packet if needed */
1128 data_buf = NULL; /* fail safe */
1130 if (ist->decoding_needed) {
1131 switch(ist->st->codec.codec_type) {
1132 case CODEC_TYPE_AUDIO:{
1134 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1135 /* XXX: could avoid copy if PCM 16 bits with same
1136 endianness as CPU */
1137 ret = avcodec_decode_audio(&ist->st->codec, samples, &data_size,
1143 /* Some bug in mpeg audio decoder gives */
1144 /* data_size < 0, it seems they are overflows */
1145 if (data_size <= 0) {
1146 /* no audio frame */
1149 data_buf = (uint8_t *)samples;
1150 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1151 (ist->st->codec.sample_rate * ist->st->codec.channels);
1153 case CODEC_TYPE_VIDEO:
1154 data_size = (ist->st->codec.width * ist->st->codec.height * 3) / 2;
1155 /* XXX: allocate picture correctly */
1156 avcodec_get_frame_defaults(&picture);
1158 ret = avcodec_decode_video(&ist->st->codec,
1159 &picture, &got_picture, ptr, len);
1160 ist->st->quality= picture.quality;
1164 /* no picture yet */
1165 goto discard_packet;
1167 if (ist->st->codec.frame_rate_base != 0) {
1168 ist->next_pts += ((int64_t)AV_TIME_BASE *
1169 ist->st->codec.frame_rate_base) /
1170 ist->st->codec.frame_rate;
1178 switch(ist->st->codec.codec_type) {
1179 case CODEC_TYPE_AUDIO:
1180 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec.frame_size) /
1181 (ist->st->codec.sample_rate * ist->st->codec.channels);
1183 case CODEC_TYPE_VIDEO:
1184 if (ist->st->codec.frame_rate_base != 0) {
1185 ist->next_pts += ((int64_t)AV_TIME_BASE *
1186 ist->st->codec.frame_rate_base) /
1187 ist->st->codec.frame_rate;
1197 buffer_to_free = NULL;
1198 if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO) {
1199 pre_process_video_frame(ist, (AVPicture *)&picture,
1203 /* frame rate emulation */
1204 if (ist->st->codec.rate_emu) {
1205 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec.frame_rate_base, 1000000, ist->st->codec.frame_rate);
1206 int64_t now = av_gettime() - ist->start;
1214 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1215 is the one of the next displayed one */
1216 /* XXX: add mpeg4 too ? */
1217 if (ist->st->codec.codec_id == CODEC_ID_MPEG1VIDEO) {
1218 if (ist->st->codec.pict_type != B_TYPE) {
1220 tmp = ist->last_ip_pts;
1221 ist->last_ip_pts = ist->frac_pts.val;
1222 ist->frac_pts.val = tmp;
1226 /* if output time reached then transcode raw format,
1227 encode packets and output them */
1228 if (start_time == 0 || ist->pts >= start_time)
1229 for(i=0;i<nb_ostreams;i++) {
1233 if (ost->source_index == ist_index) {
1234 os = output_files[ost->file_index];
1237 printf("%d: got pts=%0.3f %0.3f\n", i,
1238 (double)pkt->pts / AV_TIME_BASE,
1239 ((double)ist->pts / AV_TIME_BASE) -
1240 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1242 /* set the input output pts pairs */
1243 ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index])/ AV_TIME_BASE;
1245 if (ost->encoding_needed) {
1246 switch(ost->st->codec.codec_type) {
1247 case CODEC_TYPE_AUDIO:
1248 do_audio_out(os, ost, ist, data_buf, data_size);
1250 case CODEC_TYPE_VIDEO:
1251 do_video_out(os, ost, ist, &picture, &frame_size);
1252 video_size += frame_size;
1253 if (do_vstats && frame_size)
1254 do_video_stats(os, ost, frame_size);
1260 AVFrame avframe; //FIXME/XXX remove this
1262 av_init_packet(&opkt);
1264 /* no reencoding needed : output the packet directly */
1265 /* force the input stream PTS */
1267 avcodec_get_frame_defaults(&avframe);
1268 ost->st->codec.coded_frame= &avframe;
1269 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1271 if(ost->st->codec.codec_type == CODEC_TYPE_AUDIO)
1272 audio_size += data_size;
1273 else if (ost->st->codec.codec_type == CODEC_TYPE_VIDEO) {
1274 video_size += data_size;
1278 opkt.stream_index= ost->index;
1279 opkt.data= data_buf;
1280 opkt.size= data_size;
1281 if(pkt->pts != AV_NOPTS_VALUE)
1282 opkt.pts= pkt->pts + input_files_ts_offset[ist->file_index];
1284 opkt.pts= AV_NOPTS_VALUE;
1285 opkt.dts= pkt->dts + input_files_ts_offset[ist->file_index];
1286 opkt.flags= pkt->flags;
1288 av_interleaved_write_frame(os, &opkt);
1289 ost->st->codec.frame_number++;
1290 ost->frame_number++;
1294 av_free(buffer_to_free);
1300 for(i=0;i<nb_ostreams;i++) {
1302 if (ost->source_index == ist_index) {
1303 AVCodecContext *enc= &ost->st->codec;
1304 os = output_files[ost->file_index];
1306 if(ost->st->codec.codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1308 if(ost->st->codec.codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1311 if (ost->encoding_needed) {
1314 av_init_packet(&pkt);
1315 pkt.stream_index= ost->index;
1317 switch(ost->st->codec.codec_type) {
1318 case CODEC_TYPE_AUDIO:
1319 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1321 pkt.flags |= PKT_FLAG_KEY;
1323 case CODEC_TYPE_VIDEO:
1324 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1326 if(enc->coded_frame && enc->coded_frame->key_frame)
1327 pkt.flags |= PKT_FLAG_KEY;
1328 if (ost->logfile && enc->stats_out) {
1329 fprintf(ost->logfile, "%s", enc->stats_out);
1338 pkt.data= bit_buffer;
1340 if(enc->coded_frame)
1341 pkt.pts= enc->coded_frame->pts;
1342 av_interleaved_write_frame(os, &pkt);
1356 * The following code is the main loop of the file converter
1358 static int av_encode(AVFormatContext **output_files,
1359 int nb_output_files,
1360 AVFormatContext **input_files,
1362 AVStreamMap *stream_maps, int nb_stream_maps)
1364 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1365 AVFormatContext *is, *os;
1366 AVCodecContext *codec, *icodec;
1367 AVOutputStream *ost, **ost_table = NULL;
1368 AVInputStream *ist, **ist_table = NULL;
1369 AVInputFile *file_table;
1370 AVFormatContext *stream_no_data;
1373 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1377 /* input stream init */
1379 for(i=0;i<nb_input_files;i++) {
1380 is = input_files[i];
1381 file_table[i].ist_index = j;
1382 file_table[i].nb_streams = is->nb_streams;
1383 j += is->nb_streams;
1387 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1391 for(i=0;i<nb_istreams;i++) {
1392 ist = av_mallocz(sizeof(AVInputStream));
1398 for(i=0;i<nb_input_files;i++) {
1399 is = input_files[i];
1400 for(k=0;k<is->nb_streams;k++) {
1401 ist = ist_table[j++];
1402 ist->st = is->streams[k];
1403 ist->file_index = i;
1405 ist->discard = 1; /* the stream is discarded by default
1408 if (ist->st->codec.rate_emu) {
1409 ist->start = av_gettime();
1415 /* output stream init */
1417 for(i=0;i<nb_output_files;i++) {
1418 os = output_files[i];
1419 nb_ostreams += os->nb_streams;
1421 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1422 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1426 /* Sanity check the mapping args -- do the input files & streams exist? */
1427 for(i=0;i<nb_stream_maps;i++) {
1428 int fi = stream_maps[i].file_index;
1429 int si = stream_maps[i].stream_index;
1431 if (fi < 0 || fi > nb_input_files - 1 ||
1432 si < 0 || si > file_table[fi].nb_streams - 1) {
1433 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1438 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1441 for(i=0;i<nb_ostreams;i++) {
1442 ost = av_mallocz(sizeof(AVOutputStream));
1449 for(k=0;k<nb_output_files;k++) {
1450 os = output_files[k];
1451 for(i=0;i<os->nb_streams;i++) {
1453 ost = ost_table[n++];
1454 ost->file_index = k;
1456 ost->st = os->streams[i];
1457 if (nb_stream_maps > 0) {
1458 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1459 stream_maps[n-1].stream_index;
1461 /* Sanity check that the stream types match */
1462 if (ist_table[ost->source_index]->st->codec.codec_type != ost->st->codec.codec_type) {
1463 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1464 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1465 ost->file_index, ost->index);
1470 /* get corresponding input stream index : we select the first one with the right type */
1472 for(j=0;j<nb_istreams;j++) {
1475 ist->st->codec.codec_type == ost->st->codec.codec_type) {
1476 ost->source_index = j;
1483 /* try again and reuse existing stream */
1484 for(j=0;j<nb_istreams;j++) {
1486 if (ist->st->codec.codec_type == ost->st->codec.codec_type) {
1487 ost->source_index = j;
1492 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1493 ost->file_index, ost->index);
1498 ist = ist_table[ost->source_index];
1503 /* for each output stream, we compute the right encoding parameters */
1504 for(i=0;i<nb_ostreams;i++) {
1506 ist = ist_table[ost->source_index];
1508 codec = &ost->st->codec;
1509 icodec = &ist->st->codec;
1511 if (ost->st->stream_copy) {
1512 /* if stream_copy is selected, no need to decode or encode */
1513 codec->codec_id = icodec->codec_id;
1514 codec->codec_type = icodec->codec_type;
1515 if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1516 codec->bit_rate = icodec->bit_rate;
1517 switch(codec->codec_type) {
1518 case CODEC_TYPE_AUDIO:
1519 codec->sample_rate = icodec->sample_rate;
1520 codec->channels = icodec->channels;
1521 codec->frame_size = icodec->frame_size;
1522 codec->block_align= icodec->block_align;
1524 case CODEC_TYPE_VIDEO:
1525 codec->frame_rate = icodec->frame_rate;
1526 codec->frame_rate_base = icodec->frame_rate_base;
1527 codec->width = icodec->width;
1528 codec->height = icodec->height;
1534 switch(codec->codec_type) {
1535 case CODEC_TYPE_AUDIO:
1536 if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1539 if (codec->channels == icodec->channels &&
1540 codec->sample_rate == icodec->sample_rate) {
1541 ost->audio_resample = 0;
1543 if (codec->channels != icodec->channels &&
1544 (icodec->codec_id == CODEC_ID_AC3 ||
1545 icodec->codec_id == CODEC_ID_DTS)) {
1546 /* Special case for 5:1 AC3 and DTS input */
1547 /* and mono or stereo output */
1548 /* Request specific number of channels */
1549 icodec->channels = codec->channels;
1550 if (codec->sample_rate == icodec->sample_rate)
1551 ost->audio_resample = 0;
1553 ost->audio_resample = 1;
1556 ost->audio_resample = 1;
1559 if(audio_sync_method>1)
1560 ost->audio_resample = 1;
1562 if(ost->audio_resample){
1563 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1564 codec->sample_rate, icodec->sample_rate);
1566 printf("Can't resample. Aborting.\n");
1570 ist->decoding_needed = 1;
1571 ost->encoding_needed = 1;
1573 case CODEC_TYPE_VIDEO:
1574 if (codec->width == icodec->width &&
1575 codec->height == icodec->height &&
1576 frame_topBand == 0 &&
1577 frame_bottomBand == 0 &&
1578 frame_leftBand == 0 &&
1579 frame_rightBand == 0 &&
1580 frame_padtop == 0 &&
1581 frame_padbottom == 0 &&
1582 frame_padleft == 0 &&
1583 frame_padright == 0)
1585 ost->video_resample = 0;
1586 ost->video_crop = 0;
1588 } else if ((codec->width == icodec->width -
1589 (frame_leftBand + frame_rightBand)) &&
1590 (codec->height == icodec->height -
1591 (frame_topBand + frame_bottomBand)))
1593 ost->video_resample = 0;
1594 ost->video_crop = 1;
1595 ost->topBand = frame_topBand;
1596 ost->leftBand = frame_leftBand;
1597 } else if ((codec->width == icodec->width +
1598 (frame_padleft + frame_padright)) &&
1599 (codec->height == icodec->height +
1600 (frame_padtop + frame_padbottom))) {
1601 ost->video_resample = 0;
1602 ost->video_crop = 0;
1604 ost->padtop = frame_padtop;
1605 ost->padleft = frame_padleft;
1606 ost->padbottom = frame_padbottom;
1607 ost->padright = frame_padright;
1608 avcodec_get_frame_defaults(&ost->pict_tmp);
1609 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1610 codec->width, codec->height ) )
1613 ost->video_resample = 1;
1614 ost->video_crop = 0; // cropping is handled as part of resample
1615 avcodec_get_frame_defaults(&ost->pict_tmp);
1616 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1617 codec->width, codec->height ) )
1620 ost->img_resample_ctx = img_resample_full_init(
1621 ost->st->codec.width, ost->st->codec.height,
1622 ist->st->codec.width, ist->st->codec.height,
1623 frame_topBand, frame_bottomBand,
1624 frame_leftBand, frame_rightBand,
1625 frame_padtop, frame_padbottom,
1626 frame_padleft, frame_padright);
1628 ost->padtop = frame_padtop;
1629 ost->padleft = frame_padleft;
1630 ost->padbottom = frame_padbottom;
1631 ost->padright = frame_padright;
1634 ost->encoding_needed = 1;
1635 ist->decoding_needed = 1;
1641 if (ost->encoding_needed &&
1642 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1643 char logfilename[1024];
1648 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1650 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1651 if (codec->flags & CODEC_FLAG_PASS1) {
1652 f = fopen(logfilename, "w");
1654 perror(logfilename);
1659 /* read the log file */
1660 f = fopen(logfilename, "r");
1662 perror(logfilename);
1665 fseek(f, 0, SEEK_END);
1667 fseek(f, 0, SEEK_SET);
1668 logbuffer = av_malloc(size + 1);
1670 fprintf(stderr, "Could not allocate log buffer\n");
1673 size = fread(logbuffer, 1, size, f);
1675 logbuffer[size] = '\0';
1676 codec->stats_in = logbuffer;
1680 if(codec->codec_type == CODEC_TYPE_VIDEO){
1681 int size= codec->width * codec->height;
1682 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1687 bit_buffer = av_malloc(bit_buffer_size);
1691 /* dump the file output parameters - cannot be done before in case
1693 for(i=0;i<nb_output_files;i++) {
1694 dump_format(output_files[i], i, output_files[i]->filename, 1);
1697 /* dump the stream mapping */
1699 fprintf(stderr, "Stream mapping:\n");
1700 for(i=0;i<nb_ostreams;i++) {
1702 fprintf(stderr, " Stream #%d.%d -> #%d.%d\n",
1703 ist_table[ost->source_index]->file_index,
1704 ist_table[ost->source_index]->index,
1710 /* open each encoder */
1711 for(i=0;i<nb_ostreams;i++) {
1713 if (ost->encoding_needed) {
1715 codec = avcodec_find_encoder(ost->st->codec.codec_id);
1717 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1718 ost->file_index, ost->index);
1721 if (avcodec_open(&ost->st->codec, codec) < 0) {
1722 fprintf(stderr, "Error while opening codec for stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1723 ost->file_index, ost->index);
1726 extra_size += ost->st->codec.extradata_size;
1730 /* open each decoder */
1731 for(i=0;i<nb_istreams;i++) {
1733 if (ist->decoding_needed) {
1735 codec = avcodec_find_decoder(ist->st->codec.codec_id);
1737 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1738 ist->st->codec.codec_id, ist->file_index, ist->index);
1741 if (avcodec_open(&ist->st->codec, codec) < 0) {
1742 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1743 ist->file_index, ist->index);
1746 //if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO)
1747 // ist->st->codec.flags |= CODEC_FLAG_REPEAT_FIELD;
1752 for(i=0;i<nb_istreams;i++) {
1754 is = input_files[ist->file_index];
1756 ist->next_pts = ist->st->start_time;
1757 if(ist->next_pts == AV_NOPTS_VALUE)
1762 /* compute buffer size max (should use a complete heuristic) */
1763 for(i=0;i<nb_input_files;i++) {
1764 file_table[i].buffer_size_max = 2048;
1767 /* set meta data information from input file if required */
1768 for (i=0;i<nb_meta_data_maps;i++) {
1769 AVFormatContext *out_file;
1770 AVFormatContext *in_file;
1772 int out_file_index = meta_data_maps[i].out_file;
1773 int in_file_index = meta_data_maps[i].in_file;
1774 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1775 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1779 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1780 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1785 out_file = output_files[out_file_index];
1786 in_file = input_files[in_file_index];
1788 strcpy(out_file->title, in_file->title);
1789 strcpy(out_file->author, in_file->author);
1790 strcpy(out_file->copyright, in_file->copyright);
1791 strcpy(out_file->comment, in_file->comment);
1792 strcpy(out_file->album, in_file->album);
1793 out_file->year = in_file->year;
1794 out_file->track = in_file->track;
1795 strcpy(out_file->genre, in_file->genre);
1798 /* open files and write file headers */
1799 for(i=0;i<nb_output_files;i++) {
1800 os = output_files[i];
1801 if (av_write_header(os) < 0) {
1802 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1808 #ifndef CONFIG_WIN32
1809 if ( !using_stdin && verbose >= 0) {
1810 fprintf(stderr, "Press [q] to stop encoding\n");
1811 url_set_interrupt_cb(decode_interrupt_cb);
1819 for(; received_sigterm == 0;) {
1820 int file_index, ist_index;
1828 /* if 'q' pressed, exits */
1832 /* read_key() returns 0 on EOF */
1838 /* select the stream that we must read now by looking at the
1839 smallest output pts */
1841 for(i=0;i<nb_ostreams;i++) {
1844 os = output_files[ost->file_index];
1845 ist = ist_table[ost->source_index];
1846 if(ost->st->codec.codec_type == CODEC_TYPE_VIDEO)
1847 opts = (double)ost->sync_opts * ost->st->codec.frame_rate_base / ost->st->codec.frame_rate;
1849 opts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1850 ipts = (double)ist->pts;
1851 if (!file_table[ist->file_index].eof_reached){
1852 if(ipts < ipts_min) {
1854 if(input_sync ) file_index = ist->file_index;
1856 if(opts < opts_min) {
1858 if(!input_sync) file_index = ist->file_index;
1861 if(ost->frame_number >= max_frames[ost->st->codec.codec_type]){
1866 /* if none, if is finished */
1867 if (file_index < 0) {
1871 /* finish if recording time exhausted */
1872 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1875 /* read a frame from it and output it in the fifo */
1876 is = input_files[file_index];
1877 if (av_read_frame(is, &pkt) < 0) {
1878 file_table[file_index].eof_reached = 1;
1883 stream_no_data = is;
1888 av_pkt_dump(stdout, &pkt, do_hex_dump);
1890 /* the following test is needed in case new streams appear
1891 dynamically in stream : we ignore them */
1892 if (pkt.stream_index >= file_table[file_index].nb_streams)
1893 goto discard_packet;
1894 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1895 ist = ist_table[ist_index];
1897 goto discard_packet;
1899 // fprintf(stderr, "next:%lld dts:%lld off:%lld %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec.codec_type);
1900 if (pkt.dts != AV_NOPTS_VALUE) {
1901 int64_t delta= pkt.dts - ist->next_pts;
1902 if(ABS(delta) > 10LL*AV_TIME_BASE && !copy_ts){
1903 input_files_ts_offset[ist->file_index]-= delta;
1905 fprintf(stderr, "timestamp discontinuity %lld, new offset= %lld\n", delta, input_files_ts_offset[ist->file_index]);
1906 for(i=0; i<file_table[file_index].nb_streams; i++){
1907 int index= file_table[file_index].ist_index + i;
1908 ist_table[index]->next_pts += delta;
1909 ist_table[index]->is_start=1;
1914 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1915 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1918 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1919 ist->file_index, ist->index);
1921 av_free_packet(&pkt);
1926 av_free_packet(&pkt);
1928 /* dump report by using the output first video and audio streams */
1929 print_report(output_files, ost_table, nb_ostreams, 0);
1932 /* at the end of stream, we must flush the decoder buffers */
1933 for(i=0;i<nb_istreams;i++) {
1935 if (ist->decoding_needed) {
1936 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1942 /* write the trailer if needed and close file */
1943 for(i=0;i<nb_output_files;i++) {
1944 os = output_files[i];
1945 av_write_trailer(os);
1948 /* dump report by using the first video and audio streams */
1949 print_report(output_files, ost_table, nb_ostreams, 1);
1951 /* close each encoder */
1952 for(i=0;i<nb_ostreams;i++) {
1954 if (ost->encoding_needed) {
1955 av_freep(&ost->st->codec.stats_in);
1956 avcodec_close(&ost->st->codec);
1960 /* close each decoder */
1961 for(i=0;i<nb_istreams;i++) {
1963 if (ist->decoding_needed) {
1964 avcodec_close(&ist->st->codec);
1972 av_free(file_table);
1975 for(i=0;i<nb_istreams;i++) {
1982 for(i=0;i<nb_ostreams;i++) {
1986 fclose(ost->logfile);
1987 ost->logfile = NULL;
1989 fifo_free(&ost->fifo); /* works even if fifo is not
1990 initialized but set to zero */
1991 av_free(ost->pict_tmp.data[0]);
1992 if (ost->video_resample)
1993 img_resample_close(ost->img_resample_ctx);
1994 if (ost->audio_resample)
1995 audio_resample_close(ost->resample);
2008 int file_read(const char *filename)
2011 unsigned char buffer[1024];
2014 if (url_open(&h, filename, O_RDONLY) < 0) {
2015 printf("could not open '%s'\n", filename);
2019 len = url_read(h, buffer, sizeof(buffer));
2022 for(i=0;i<len;i++) putchar(buffer[i]);
2029 static void opt_image_format(const char *arg)
2033 for(f = first_image_format; f != NULL; f = f->next) {
2034 if (!strcmp(arg, f->name))
2038 fprintf(stderr, "Unknown image format: '%s'\n", arg);
2044 static void opt_format(const char *arg)
2046 /* compatibility stuff for pgmyuv */
2047 if (!strcmp(arg, "pgmyuv")) {
2048 pgmyuv_compatibility_hack=1;
2049 // opt_image_format(arg);
2053 file_iformat = av_find_input_format(arg);
2054 file_oformat = guess_format(arg, NULL, NULL);
2055 if (!file_iformat && !file_oformat) {
2056 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2061 static void opt_video_bitrate(const char *arg)
2063 video_bit_rate = atoi(arg) * 1000;
2066 static void opt_video_bitrate_tolerance(const char *arg)
2068 video_bit_rate_tolerance = atoi(arg) * 1000;
2071 static void opt_video_bitrate_max(const char *arg)
2073 video_rc_max_rate = atoi(arg) * 1000;
2076 static void opt_video_bitrate_min(const char *arg)
2078 video_rc_min_rate = atoi(arg) * 1000;
2081 static void opt_video_buffer_size(const char *arg)
2083 video_rc_buffer_size = atoi(arg) * 8*1024;
2086 static void opt_video_rc_eq(char *arg)
2091 static void opt_video_rc_override_string(char *arg)
2093 video_rc_override_string = arg;
2097 static void opt_workaround_bugs(const char *arg)
2099 workaround_bugs = atoi(arg);
2102 static void opt_dct_algo(const char *arg)
2104 dct_algo = atoi(arg);
2107 static void opt_idct_algo(const char *arg)
2109 idct_algo = atoi(arg);
2112 static void opt_me_threshold(const char *arg)
2114 me_threshold = atoi(arg);
2117 static void opt_mb_threshold(const char *arg)
2119 mb_threshold = atoi(arg);
2122 static void opt_error_resilience(const char *arg)
2124 error_resilience = atoi(arg);
2127 static void opt_error_concealment(const char *arg)
2129 error_concealment = atoi(arg);
2132 static void opt_debug(const char *arg)
2137 static void opt_vismv(const char *arg)
2139 debug_mv = atoi(arg);
2142 static void opt_verbose(const char *arg)
2144 verbose = atoi(arg);
2145 av_log_set_level(atoi(arg));
2148 static void opt_frame_rate(const char *arg)
2150 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2151 fprintf(stderr, "Incorrect frame rate\n");
2156 static void opt_frame_crop_top(const char *arg)
2158 frame_topBand = atoi(arg);
2159 if (frame_topBand < 0) {
2160 fprintf(stderr, "Incorrect top crop size\n");
2163 if ((frame_topBand % 2) != 0) {
2164 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2167 if ((frame_topBand) >= frame_height){
2168 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2171 frame_height -= frame_topBand;
2174 static void opt_frame_crop_bottom(const char *arg)
2176 frame_bottomBand = atoi(arg);
2177 if (frame_bottomBand < 0) {
2178 fprintf(stderr, "Incorrect bottom crop size\n");
2181 if ((frame_bottomBand % 2) != 0) {
2182 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2185 if ((frame_bottomBand) >= frame_height){
2186 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2189 frame_height -= frame_bottomBand;
2192 static void opt_frame_crop_left(const char *arg)
2194 frame_leftBand = atoi(arg);
2195 if (frame_leftBand < 0) {
2196 fprintf(stderr, "Incorrect left crop size\n");
2199 if ((frame_leftBand % 2) != 0) {
2200 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2203 if ((frame_leftBand) >= frame_width){
2204 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2207 frame_width -= frame_leftBand;
2210 static void opt_frame_crop_right(const char *arg)
2212 frame_rightBand = atoi(arg);
2213 if (frame_rightBand < 0) {
2214 fprintf(stderr, "Incorrect right crop size\n");
2217 if ((frame_rightBand % 2) != 0) {
2218 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2221 if ((frame_rightBand) >= frame_width){
2222 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2225 frame_width -= frame_rightBand;
2228 static void opt_frame_size(const char *arg)
2230 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2231 fprintf(stderr, "Incorrect frame size\n");
2234 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2235 fprintf(stderr, "Frame size must be a multiple of 2\n");
2241 #define SCALEBITS 10
2242 #define ONE_HALF (1 << (SCALEBITS - 1))
2243 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2245 #define RGB_TO_Y(r, g, b) \
2246 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2247 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2249 #define RGB_TO_U(r1, g1, b1, shift)\
2250 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2251 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2253 #define RGB_TO_V(r1, g1, b1, shift)\
2254 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2255 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2257 static void opt_pad_color(const char *arg) {
2258 /* Input is expected to be six hex digits similar to
2259 how colors are expressed in html tags (but without the #) */
2260 int rgb = strtol(arg, NULL, 16);
2264 g = ((rgb >> 8) & 255);
2267 padcolor[0] = RGB_TO_Y(r,g,b);
2268 padcolor[1] = RGB_TO_U(r,g,b,0);
2269 padcolor[2] = RGB_TO_V(r,g,b,0);
2272 static void opt_frame_pad_top(const char *arg)
2274 frame_padtop = atoi(arg);
2275 if (frame_padtop < 0) {
2276 fprintf(stderr, "Incorrect top pad size\n");
2279 if ((frame_padtop % 2) != 0) {
2280 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2285 static void opt_frame_pad_bottom(const char *arg)
2287 frame_padbottom = atoi(arg);
2288 if (frame_padbottom < 0) {
2289 fprintf(stderr, "Incorrect bottom pad size\n");
2292 if ((frame_padbottom % 2) != 0) {
2293 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2299 static void opt_frame_pad_left(const char *arg)
2301 frame_padleft = atoi(arg);
2302 if (frame_padleft < 0) {
2303 fprintf(stderr, "Incorrect left pad size\n");
2306 if ((frame_padleft % 2) != 0) {
2307 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2313 static void opt_frame_pad_right(const char *arg)
2315 frame_padright = atoi(arg);
2316 if (frame_padright < 0) {
2317 fprintf(stderr, "Incorrect right pad size\n");
2320 if ((frame_padright % 2) != 0) {
2321 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2327 static void opt_frame_pix_fmt(const char *arg)
2329 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2332 static void opt_frame_aspect_ratio(const char *arg)
2338 p = strchr(arg, ':');
2340 x = strtol(arg, (char **)&arg, 10);
2342 y = strtol(arg+1, (char **)&arg, 10);
2344 ar = (double)x / (double)y;
2346 ar = strtod(arg, (char **)&arg);
2349 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2352 frame_aspect_ratio = ar;
2355 static void opt_gop_size(const char *arg)
2357 gop_size = atoi(arg);
2360 static void opt_b_frames(const char *arg)
2362 b_frames = atoi(arg);
2363 if (b_frames > FF_MAX_B_FRAMES) {
2364 fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2366 } else if (b_frames < 1) {
2367 fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2372 static void opt_mb_decision(const char *arg)
2374 mb_decision = atoi(arg);
2377 static void opt_mb_cmp(const char *arg)
2382 static void opt_ildct_cmp(const char *arg)
2384 ildct_cmp = atoi(arg);
2387 static void opt_sub_cmp(const char *arg)
2389 sub_cmp = atoi(arg);
2392 static void opt_cmp(const char *arg)
2397 static void opt_pre_cmp(const char *arg)
2399 pre_cmp = atoi(arg);
2402 static void opt_pre_me(const char *arg)
2407 static void opt_lumi_mask(const char *arg)
2409 lumi_mask = atof(arg);
2412 static void opt_dark_mask(const char *arg)
2414 dark_mask = atof(arg);
2417 static void opt_scplx_mask(const char *arg)
2419 scplx_mask = atof(arg);
2422 static void opt_tcplx_mask(const char *arg)
2424 tcplx_mask = atof(arg);
2427 static void opt_p_mask(const char *arg)
2432 static void opt_qscale(const char *arg)
2434 video_qscale = atof(arg);
2435 if (video_qscale < 0.01 ||
2436 video_qscale > 255) {
2437 fprintf(stderr, "qscale must be >= 0.01 and <= 255\n");
2442 static void opt_lmax(const char *arg)
2444 video_lmax = atof(arg)*FF_QP2LAMBDA;
2447 static void opt_lmin(const char *arg)
2449 video_lmin = atof(arg)*FF_QP2LAMBDA;
2452 static void opt_qmin(const char *arg)
2454 video_qmin = atoi(arg);
2455 if (video_qmin < 0 ||
2457 fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2462 static void opt_qmax(const char *arg)
2464 video_qmax = atoi(arg);
2465 if (video_qmax < 0 ||
2467 fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2472 static void opt_mb_qmin(const char *arg)
2474 video_mb_qmin = atoi(arg);
2475 if (video_mb_qmin < 0 ||
2476 video_mb_qmin > 31) {
2477 fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2482 static void opt_mb_qmax(const char *arg)
2484 video_mb_qmax = atoi(arg);
2485 if (video_mb_qmax < 0 ||
2486 video_mb_qmax > 31) {
2487 fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2492 static void opt_qdiff(const char *arg)
2494 video_qdiff = atoi(arg);
2495 if (video_qdiff < 0 ||
2497 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2502 static void opt_qblur(const char *arg)
2504 video_qblur = atof(arg);
2507 static void opt_qcomp(const char *arg)
2509 video_qcomp = atof(arg);
2512 static void opt_rc_initial_cplx(const char *arg)
2514 video_rc_initial_cplx = atof(arg);
2516 static void opt_b_qfactor(const char *arg)
2518 video_b_qfactor = atof(arg);
2520 static void opt_i_qfactor(const char *arg)
2522 video_i_qfactor = atof(arg);
2524 static void opt_b_qoffset(const char *arg)
2526 video_b_qoffset = atof(arg);
2528 static void opt_i_qoffset(const char *arg)
2530 video_i_qoffset = atof(arg);
2533 static void opt_ibias(const char *arg)
2535 video_intra_quant_bias = atoi(arg);
2537 static void opt_pbias(const char *arg)
2539 video_inter_quant_bias = atoi(arg);
2542 static void opt_packet_size(const char *arg)
2544 packet_size= atoi(arg);
2547 static void opt_error_rate(const char *arg)
2549 error_rate= atoi(arg);
2552 static void opt_strict(const char *arg)
2557 static void opt_top_field_first(const char *arg)
2559 top_field_first= atoi(arg);
2562 static void opt_noise_reduction(const char *arg)
2564 noise_reduction= atoi(arg);
2567 static void opt_qns(const char *arg)
2572 static void opt_sc_threshold(const char *arg)
2574 sc_threshold= atoi(arg);
2577 static void opt_me_range(const char *arg)
2579 me_range = atoi(arg);
2582 static void opt_thread_count(const char *arg)
2584 thread_count= atoi(arg);
2585 #if !defined(HAVE_THREADS)
2587 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2591 static void opt_audio_bitrate(const char *arg)
2593 audio_bit_rate = atoi(arg) * 1000;
2596 static void opt_audio_rate(const char *arg)
2598 audio_sample_rate = atoi(arg);
2601 static void opt_audio_channels(const char *arg)
2603 audio_channels = atoi(arg);
2606 static void opt_video_device(const char *arg)
2608 video_device = av_strdup(arg);
2611 static void opt_grab_device(const char *arg)
2613 grab_device = av_strdup(arg);
2616 static void opt_video_channel(const char *arg)
2618 video_channel = strtol(arg, NULL, 0);
2621 static void opt_video_standard(const char *arg)
2623 video_standard = av_strdup(arg);
2626 static void opt_audio_device(const char *arg)
2628 audio_device = av_strdup(arg);
2631 static void opt_audio_codec(const char *arg)
2635 if (!strcmp(arg, "copy")) {
2636 audio_stream_copy = 1;
2640 if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_AUDIO)
2645 fprintf(stderr, "Unknown audio codec '%s'\n", arg);
2648 audio_codec_id = p->id;
2653 static void opt_audio_tag(const char *arg)
2656 audio_codec_tag= strtol(arg, &tail, 0);
2659 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2662 static void opt_video_tag(const char *arg)
2665 video_codec_tag= strtol(arg, &tail, 0);
2668 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2671 static void add_frame_hooker(const char *arg)
2676 char *args = av_strdup(arg);
2680 argv[0] = strtok(args, " ");
2681 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2684 i = frame_hook_add(argc, argv);
2687 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2692 const char *motion_str[] = {
2702 static void opt_motion_estimation(const char *arg)
2708 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2711 if (!strcmp(*p, arg))
2715 me_method = (p - motion_str) + 1;
2718 static void opt_video_codec(const char *arg)
2722 if (!strcmp(arg, "copy")) {
2723 video_stream_copy = 1;
2727 if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_VIDEO)
2732 fprintf(stderr, "Unknown video codec '%s'\n", arg);
2735 video_codec_id = p->id;
2740 static void opt_map(const char *arg)
2746 m = &stream_maps[nb_stream_maps++];
2748 m->file_index = strtol(arg, (char **)&p, 0);
2752 m->stream_index = strtol(p, (char **)&p, 0);
2755 static void opt_map_meta_data(const char *arg)
2761 m = &meta_data_maps[nb_meta_data_maps++];
2763 m->out_file = strtol(arg, (char **)&p, 0);
2767 m->in_file = strtol(p, (char **)&p, 0);
2770 static void opt_recording_time(const char *arg)
2772 recording_time = parse_date(arg, 1);
2775 static void opt_start_time(const char *arg)
2777 start_time = parse_date(arg, 1);
2780 static void opt_rec_timestamp(const char *arg)
2782 rec_timestamp = parse_date(arg, 0) / 1000000;
2785 static void opt_input_ts_offset(const char *arg)
2787 input_ts_offset = parse_date(arg, 1);
2790 static void opt_input_file(const char *filename)
2792 AVFormatContext *ic;
2793 AVFormatParameters params, *ap = ¶ms;
2794 int err, i, ret, rfps, rfps_base;
2797 if (!strcmp(filename, "-"))
2800 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2801 !strcmp( filename, "/dev/stdin" );
2803 /* get default parameters from command line */
2804 memset(ap, 0, sizeof(*ap));
2805 ap->sample_rate = audio_sample_rate;
2806 ap->channels = audio_channels;
2807 ap->frame_rate = frame_rate;
2808 ap->frame_rate_base = frame_rate_base;
2809 ap->width = frame_width + frame_padleft + frame_padright;
2810 ap->height = frame_height + frame_padtop + frame_padbottom;
2811 ap->image_format = image_format;
2812 ap->pix_fmt = frame_pix_fmt;
2813 ap->device = grab_device;
2814 ap->channel = video_channel;
2815 ap->standard = video_standard;
2816 ap->video_codec_id = video_codec_id;
2817 ap->audio_codec_id = audio_codec_id;
2818 if(pgmyuv_compatibility_hack)
2819 ap->video_codec_id= CODEC_ID_PGMYUV;
2821 /* open the input file with generic libav function */
2822 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2824 print_error(filename, err);
2828 /* If not enough info to get the stream parameters, we decode the
2829 first frames to get it. (used in mpeg case for example) */
2830 ret = av_find_stream_info(ic);
2831 if (ret < 0 && verbose >= 0) {
2832 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2836 timestamp = start_time;
2837 /* add the stream start time */
2838 if (ic->start_time != AV_NOPTS_VALUE)
2839 timestamp += ic->start_time;
2841 /* if seeking requested, we execute it */
2842 if (start_time != 0) {
2843 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2845 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2846 filename, (double)timestamp / AV_TIME_BASE);
2848 /* reset seek info */
2852 /* update the current parameters so that they match the one of the input stream */
2853 for(i=0;i<ic->nb_streams;i++) {
2854 AVCodecContext *enc = &ic->streams[i]->codec;
2855 #if defined(HAVE_THREADS)
2857 avcodec_thread_init(enc, thread_count);
2859 enc->thread_count= thread_count;
2860 switch(enc->codec_type) {
2861 case CODEC_TYPE_AUDIO:
2862 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2863 audio_channels = enc->channels;
2864 audio_sample_rate = enc->sample_rate;
2866 case CODEC_TYPE_VIDEO:
2867 frame_height = enc->height;
2868 frame_width = enc->width;
2869 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2870 frame_pix_fmt = enc->pix_fmt;
2871 rfps = ic->streams[i]->r_frame_rate;
2872 rfps_base = ic->streams[i]->r_frame_rate_base;
2873 enc->workaround_bugs = workaround_bugs;
2874 enc->error_resilience = error_resilience;
2875 enc->error_concealment = error_concealment;
2876 enc->idct_algo = idct_algo;
2878 enc->debug_mv = debug_mv;
2879 enc->lowres= lowres;
2881 enc->flags|= CODEC_FLAG_BITEXACT;
2883 enc->debug |= FF_DEBUG_MV;
2885 if (enc->frame_rate != rfps || enc->frame_rate_base != rfps_base) {
2888 fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2889 i, (float)enc->frame_rate / enc->frame_rate_base, enc->frame_rate, enc->frame_rate_base,
2891 (float)rfps / rfps_base, rfps, rfps_base);
2893 /* update the current frame rate to match the stream frame rate */
2895 frame_rate_base = rfps_base;
2897 enc->rate_emu = rate_emu;
2899 case CODEC_TYPE_DATA:
2906 input_files[nb_input_files] = ic;
2907 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2908 /* dump the file content */
2910 dump_format(ic, nb_input_files, filename, 0);
2913 file_iformat = NULL;
2914 file_oformat = NULL;
2915 image_format = NULL;
2923 static void opt_grab(const char *arg)
2925 file_iformat = av_find_input_format(arg);
2929 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2931 int has_video, has_audio, i, j;
2932 AVFormatContext *ic;
2936 for(j=0;j<nb_input_files;j++) {
2937 ic = input_files[j];
2938 for(i=0;i<ic->nb_streams;i++) {
2939 AVCodecContext *enc = &ic->streams[i]->codec;
2940 switch(enc->codec_type) {
2941 case CODEC_TYPE_AUDIO:
2944 case CODEC_TYPE_VIDEO:
2947 case CODEC_TYPE_DATA:
2954 *has_video_ptr = has_video;
2955 *has_audio_ptr = has_audio;
2958 static void opt_output_file(const char *filename)
2961 AVFormatContext *oc;
2962 int use_video, use_audio, nb_streams, input_has_video, input_has_audio;
2964 AVFormatParameters params, *ap = ¶ms;
2966 if (!strcmp(filename, "-"))
2969 oc = av_alloc_format_context();
2971 if (!file_oformat) {
2972 file_oformat = guess_format(NULL, filename, NULL);
2973 if (!file_oformat) {
2974 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
2980 oc->oformat = file_oformat;
2982 if (!strcmp(file_oformat->name, "ffm") &&
2983 strstart(filename, "http:", NULL)) {
2984 /* special case for files sent to ffserver: we get the stream
2985 parameters from ffserver */
2986 if (read_ffserver_streams(oc, filename) < 0) {
2987 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
2991 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy;
2992 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy;
2994 /* disable if no corresponding type found and at least one
2996 if (nb_input_files > 0) {
2997 check_audio_video_inputs(&input_has_video, &input_has_audio);
2998 if (!input_has_video)
3000 if (!input_has_audio)
3004 /* manual disable */
3005 if (audio_disable) {
3008 if (video_disable) {
3014 AVCodecContext *video_enc;
3016 st = av_new_stream(oc, nb_streams++);
3018 fprintf(stderr, "Could not alloc stream\n");
3021 #if defined(HAVE_THREADS)
3023 avcodec_thread_init(&st->codec, thread_count);
3026 video_enc = &st->codec;
3029 video_enc->codec_tag= video_codec_tag;
3031 if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
3032 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3033 if (video_stream_copy) {
3034 st->stream_copy = 1;
3035 video_enc->codec_type = CODEC_TYPE_VIDEO;
3041 codec_id = av_guess_codec(file_oformat, NULL, filename, NULL, CODEC_TYPE_VIDEO);
3042 if (video_codec_id != CODEC_ID_NONE)
3043 codec_id = video_codec_id;
3045 video_enc->codec_id = codec_id;
3046 codec = avcodec_find_encoder(codec_id);
3048 video_enc->bit_rate = video_bit_rate;
3049 video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
3050 video_enc->frame_rate = frame_rate;
3051 video_enc->frame_rate_base = frame_rate_base;
3052 if(codec && codec->supported_framerates){
3053 const AVRational *p= codec->supported_framerates;
3054 AVRational req= (AVRational){frame_rate, frame_rate_base};
3055 const AVRational *best=NULL;
3056 AVRational best_error= (AVRational){INT_MAX, 1};
3057 for(; p->den!=0; p++){
3058 AVRational error= av_sub_q(req, *p);
3059 if(error.num <0) error.num *= -1;
3060 if(av_cmp_q(error, best_error) < 0){
3065 video_enc->frame_rate = best->num;
3066 video_enc->frame_rate_base= best->den;
3069 video_enc->width = frame_width + frame_padright + frame_padleft;
3070 video_enc->height = frame_height + frame_padtop + frame_padbottom;
3071 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3072 video_enc->pix_fmt = frame_pix_fmt;
3074 if(codec && codec->pix_fmts){
3075 const enum PixelFormat *p= codec->pix_fmts;
3077 if(*p == video_enc->pix_fmt)
3081 video_enc->pix_fmt = codec->pix_fmts[0];
3085 video_enc->gop_size = gop_size;
3087 video_enc->gop_size = 0;
3088 if (video_qscale || same_quality) {
3089 video_enc->flags |= CODEC_FLAG_QSCALE;
3090 st->quality = FF_QP2LAMBDA * video_qscale;
3094 video_enc->intra_matrix = intra_matrix;
3096 video_enc->inter_matrix = inter_matrix;
3099 video_enc->flags |= CODEC_FLAG_BITEXACT;
3101 video_enc->mb_decision = mb_decision;
3102 video_enc->mb_cmp = mb_cmp;
3103 video_enc->ildct_cmp = ildct_cmp;
3104 video_enc->me_sub_cmp = sub_cmp;
3105 video_enc->me_cmp = cmp;
3106 video_enc->me_pre_cmp = pre_cmp;
3107 video_enc->pre_me = pre_me;
3108 video_enc->lumi_masking = lumi_mask;
3109 video_enc->dark_masking = dark_mask;
3110 video_enc->spatial_cplx_masking = scplx_mask;
3111 video_enc->temporal_cplx_masking = tcplx_mask;
3112 video_enc->p_masking = p_mask;
3113 video_enc->quantizer_noise_shaping= qns;
3116 video_enc->flags |= CODEC_FLAG_H263P_UMV;
3119 video_enc->flags |= CODEC_FLAG_H263P_SLICE_STRUCT;
3122 video_enc->flags |= CODEC_FLAG_H263P_AIC;
3125 video_enc->flags |= CODEC_FLAG_H263P_AIV;
3128 video_enc->flags |= CODEC_FLAG_4MV;
3131 video_enc->flags |= CODEC_FLAG_OBMC;
3134 video_enc->flags |= CODEC_FLAG_LOOP_FILTER;
3138 video_enc->flags |= CODEC_FLAG_PART;
3141 video_enc->flags |= CODEC_FLAG_ALT_SCAN;
3144 video_enc->flags |= CODEC_FLAG_TRELLIS_QUANT;
3146 if (use_scan_offset) {
3147 video_enc->flags |= CODEC_FLAG_SVCD_SCAN_OFFSET;
3150 video_enc->flags |= CODEC_FLAG_CLOSED_GOP;
3153 video_enc->flags2 |= CODEC_FLAG2_STRICT_GOP;
3156 video_enc->flags |= CODEC_FLAG_QPEL;
3159 video_enc->flags |= CODEC_FLAG_QP_RD;
3162 video_enc->flags |= CODEC_FLAG_CBP_RD;
3165 video_enc->max_b_frames = b_frames;
3166 video_enc->b_frame_strategy = 0;
3167 video_enc->b_quant_factor = 2.0;
3169 if (do_interlace_dct) {
3170 video_enc->flags |= CODEC_FLAG_INTERLACED_DCT;
3172 if (do_interlace_me) {
3173 video_enc->flags |= CODEC_FLAG_INTERLACED_ME;
3175 video_enc->qmin = video_qmin;
3176 video_enc->qmax = video_qmax;
3177 video_enc->lmin = video_lmin;
3178 video_enc->lmax = video_lmax;
3179 video_enc->mb_qmin = video_mb_qmin;
3180 video_enc->mb_qmax = video_mb_qmax;
3181 video_enc->max_qdiff = video_qdiff;
3182 video_enc->qblur = video_qblur;
3183 video_enc->qcompress = video_qcomp;
3184 video_enc->rc_eq = video_rc_eq;
3185 video_enc->debug = debug;
3186 video_enc->debug_mv = debug_mv;
3187 video_enc->thread_count = thread_count;
3188 p= video_rc_override_string;
3191 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3193 fprintf(stderr, "error parsing rc_override\n");
3196 video_enc->rc_override=
3197 av_realloc(video_enc->rc_override,
3198 sizeof(RcOverride)*(i+1));
3199 video_enc->rc_override[i].start_frame= start;
3200 video_enc->rc_override[i].end_frame = end;
3202 video_enc->rc_override[i].qscale= q;
3203 video_enc->rc_override[i].quality_factor= 1.0;
3206 video_enc->rc_override[i].qscale= 0;
3207 video_enc->rc_override[i].quality_factor= -q/100.0;
3212 video_enc->rc_override_count=i;
3214 video_enc->rc_max_rate = video_rc_max_rate;
3215 video_enc->rc_min_rate = video_rc_min_rate;
3216 video_enc->rc_buffer_size = video_rc_buffer_size;
3217 video_enc->rc_initial_buffer_occupancy = video_rc_buffer_size*3/4;
3218 video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
3219 video_enc->rc_initial_cplx= video_rc_initial_cplx;
3220 video_enc->i_quant_factor = video_i_qfactor;
3221 video_enc->b_quant_factor = video_b_qfactor;
3222 video_enc->i_quant_offset = video_i_qoffset;
3223 video_enc->b_quant_offset = video_b_qoffset;
3224 video_enc->intra_quant_bias = video_intra_quant_bias;
3225 video_enc->inter_quant_bias = video_inter_quant_bias;
3226 video_enc->dct_algo = dct_algo;
3227 video_enc->idct_algo = idct_algo;
3228 video_enc->me_threshold= me_threshold;
3229 video_enc->mb_threshold= mb_threshold;
3230 video_enc->intra_dc_precision= intra_dc_precision - 8;
3231 video_enc->strict_std_compliance = strict;
3232 video_enc->error_rate = error_rate;
3233 video_enc->noise_reduction= noise_reduction;
3234 video_enc->scenechange_threshold= sc_threshold;
3235 video_enc->me_range = me_range;
3236 video_enc->coder_type= coder;
3237 video_enc->context_model= context;
3238 video_enc->prediction_method= predictor;
3239 video_enc->profile= video_profile;
3240 video_enc->level= video_level;
3241 video_enc->nsse_weight= nsse_weight;
3242 video_enc->me_subpel_quality= subpel_quality;
3243 video_enc->frame_skip_threshold= frame_skip_threshold;
3244 video_enc->frame_skip_factor= frame_skip_factor;
3245 video_enc->frame_skip_exp= frame_skip_exp;
3246 video_enc->frame_skip_cmp= frame_skip_cmp;
3249 video_enc->rtp_mode= 1;
3250 video_enc->rtp_payload_size= packet_size;
3254 video_enc->flags|= CODEC_FLAG_PSNR;
3256 video_enc->me_method = me_method;
3261 video_enc->flags |= CODEC_FLAG_PASS1;
3263 video_enc->flags |= CODEC_FLAG_PASS2;
3270 AVCodecContext *audio_enc;
3272 st = av_new_stream(oc, nb_streams++);
3274 fprintf(stderr, "Could not alloc stream\n");
3277 #if defined(HAVE_THREADS)
3279 avcodec_thread_init(&st->codec, thread_count);
3282 audio_enc = &st->codec;
3283 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3286 audio_enc->codec_tag= audio_codec_tag;
3288 if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
3289 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3290 if (audio_stream_copy) {
3291 st->stream_copy = 1;
3292 audio_enc->channels = audio_channels;
3294 codec_id = av_guess_codec(file_oformat, NULL, filename, NULL, CODEC_TYPE_AUDIO);
3295 if (audio_codec_id != CODEC_ID_NONE)
3296 codec_id = audio_codec_id;
3297 audio_enc->codec_id = codec_id;
3299 audio_enc->bit_rate = audio_bit_rate;
3300 audio_enc->strict_std_compliance = strict;
3301 audio_enc->thread_count = thread_count;
3302 /* For audio codecs other than AC3 or DTS we limit */
3303 /* the number of coded channels to stereo */
3304 if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3305 && codec_id != CODEC_ID_DTS) {
3306 audio_enc->channels = 2;
3308 audio_enc->channels = audio_channels;
3310 audio_enc->sample_rate = audio_sample_rate;
3313 oc->nb_streams = nb_streams;
3316 fprintf(stderr, "No audio or video streams available\n");
3320 oc->timestamp = rec_timestamp;
3323 pstrcpy(oc->title, sizeof(oc->title), str_title);
3325 pstrcpy(oc->author, sizeof(oc->author), str_author);
3327 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3329 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3332 output_files[nb_output_files++] = oc;
3334 strcpy(oc->filename, filename);
3336 /* check filename in case of an image number is expected */
3337 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3338 if (filename_number_test(oc->filename) < 0) {
3339 print_error(oc->filename, AVERROR_NUMEXPECTED);
3344 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3345 /* test if it already exists to avoid loosing precious files */
3346 if (!file_overwrite &&
3347 (strchr(filename, ':') == NULL ||
3348 strstart(filename, "file:", NULL))) {
3349 if (url_exist(filename)) {
3352 if ( !using_stdin ) {
3353 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3356 if (toupper(c) != 'Y') {
3357 fprintf(stderr, "Not overwriting - exiting\n");
3362 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3369 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3370 fprintf(stderr, "Could not open '%s'\n", filename);
3375 memset(ap, 0, sizeof(*ap));
3376 ap->image_format = image_format;
3377 if (av_set_parameters(oc, ap) < 0) {
3378 fprintf(stderr, "%s: Invalid encoding parameters\n",
3383 oc->packet_size= mux_packet_size;
3384 oc->mux_rate= mux_rate;
3385 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3386 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3388 /* reset some options */
3389 file_oformat = NULL;
3390 file_iformat = NULL;
3391 image_format = NULL;
3394 audio_codec_id = CODEC_ID_NONE;
3395 video_codec_id = CODEC_ID_NONE;
3396 audio_stream_copy = 0;
3397 video_stream_copy = 0;
3400 /* prepare dummy protocols for grab */
3401 static void prepare_grab(void)
3403 int has_video, has_audio, i, j;
3404 AVFormatContext *oc;
3405 AVFormatContext *ic;
3406 AVFormatParameters vp1, *vp = &vp1;
3407 AVFormatParameters ap1, *ap = &ap1;
3409 /* see if audio/video inputs are needed */
3412 memset(ap, 0, sizeof(*ap));
3413 memset(vp, 0, sizeof(*vp));
3414 vp->frame_rate_base= 1;
3415 for(j=0;j<nb_output_files;j++) {
3416 oc = output_files[j];
3417 for(i=0;i<oc->nb_streams;i++) {
3418 AVCodecContext *enc = &oc->streams[i]->codec;
3419 switch(enc->codec_type) {
3420 case CODEC_TYPE_AUDIO:
3421 if (enc->sample_rate > ap->sample_rate)
3422 ap->sample_rate = enc->sample_rate;
3423 if (enc->channels > ap->channels)
3424 ap->channels = enc->channels;
3427 case CODEC_TYPE_VIDEO:
3428 if (enc->width > vp->width)
3429 vp->width = enc->width;
3430 if (enc->height > vp->height)
3431 vp->height = enc->height;
3433 if (vp->frame_rate_base*(int64_t)enc->frame_rate > enc->frame_rate_base*(int64_t)vp->frame_rate){
3434 vp->frame_rate = enc->frame_rate;
3435 vp->frame_rate_base = enc->frame_rate_base;
3445 if (has_video == 0 && has_audio == 0) {
3446 fprintf(stderr, "Output file must have at least one audio or video stream\n");
3451 AVInputFormat *fmt1;
3452 fmt1 = av_find_input_format(video_grab_format);
3453 vp->device = video_device;
3454 vp->channel = video_channel;
3455 vp->standard = video_standard;
3456 if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3457 fprintf(stderr, "Could not find video grab device\n");
3460 /* If not enough info to get the stream parameters, we decode the
3461 first frames to get it. */
3462 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3463 fprintf(stderr, "Could not find video grab parameters\n");
3466 /* by now video grab has one stream */
3467 ic->streams[0]->r_frame_rate = vp->frame_rate;
3468 ic->streams[0]->r_frame_rate_base = vp->frame_rate_base;
3469 input_files[nb_input_files] = ic;
3472 dump_format(ic, nb_input_files, "", 0);
3476 if (has_audio && audio_grab_format) {
3477 AVInputFormat *fmt1;
3478 fmt1 = av_find_input_format(audio_grab_format);
3479 ap->device = audio_device;
3480 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3481 fprintf(stderr, "Could not find audio grab device\n");
3484 input_files[nb_input_files] = ic;
3487 dump_format(ic, nb_input_files, "", 0);
3493 /* same option as mencoder */
3494 static void opt_pass(const char *pass_str)
3497 pass = atoi(pass_str);
3498 if (pass != 1 && pass != 2) {
3499 fprintf(stderr, "pass number can be only 1 or 2\n");
3505 #if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
3506 static int64_t getutime(void)
3508 return av_gettime();
3511 static int64_t getutime(void)
3513 struct rusage rusage;
3515 getrusage(RUSAGE_SELF, &rusage);
3516 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3520 extern int ffm_nopts;
3522 static void opt_bitexact(void)
3525 /* disable generate of real time pts in ffm (need to be supressed anyway) */
3529 static void show_formats(void)
3531 AVInputFormat *ifmt;
3532 AVOutputFormat *ofmt;
3533 AVImageFormat *image_fmt;
3536 const char **pp, *last_name;
3538 printf("File formats:\n");
3543 const char *name=NULL;
3544 const char *long_name=NULL;
3546 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3547 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3548 strcmp(ofmt->name, last_name)>0){
3550 long_name= ofmt->long_name;
3554 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3555 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3556 strcmp(ifmt->name, last_name)>0){
3558 long_name= ifmt->long_name;
3561 if(name && strcmp(ifmt->name, name)==0)
3573 long_name ? long_name:" ");
3577 printf("Image formats (filename extensions, if any, follow):\n");
3578 for(image_fmt = first_image_format; image_fmt != NULL;
3579 image_fmt = image_fmt->next) {
3582 image_fmt->img_read ? "D":" ",
3583 image_fmt->img_write ? "E":" ",
3585 image_fmt->extensions ? image_fmt->extensions:" ");
3589 printf("Codecs:\n");
3597 for(p = first_avcodec; p != NULL; p = p->next) {
3598 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3599 strcmp(p->name, last_name)>0){
3601 decode= encode= cap=0;
3603 if(p2 && strcmp(p->name, p2->name)==0){
3604 if(p->decode) decode=1;
3605 if(p->encode) encode=1;
3606 cap |= p->capabilities;
3611 last_name= p2->name;
3615 decode ? "D": (/*p2->decoder ? "d":*/" "),
3617 p2->type == CODEC_TYPE_AUDIO ? "A":"V",
3618 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3619 cap & CODEC_CAP_DR1 ? "D":" ",
3620 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3622 /* if(p2->decoder && decode==0)
3623 printf(" use %s for decoding", p2->decoder->name);*/
3628 printf("Supported file protocols:\n");
3629 for(up = first_protocol; up != NULL; up = up->next)
3630 printf(" %s:", up->name);
3633 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3634 printf("Motion estimation methods:\n");
3638 if ((pp - motion_str + 1) == ME_ZERO)
3639 printf("(fastest)");
3640 else if ((pp - motion_str + 1) == ME_FULL)
3641 printf("(slowest)");
3642 else if ((pp - motion_str + 1) == ME_EPZS)
3643 printf("(default)");
3648 "Note, the names of encoders and decoders dont always match, so there are\n"
3649 "several cases where the above table shows encoder only or decoder only entries\n"
3650 "even though both encoding and decoding are supported for example, the h263\n"
3651 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3656 void parse_matrix_coeffs(uint16_t *dest, const char *str)
3659 const char *p = str;
3666 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3673 void opt_inter_matrix(const char *arg)
3675 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3676 parse_matrix_coeffs(inter_matrix, arg);
3679 void opt_intra_matrix(const char *arg)
3681 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3682 parse_matrix_coeffs(intra_matrix, arg);
3685 static void opt_target(const char *arg)
3688 static const char const *frame_rates[] = {"25", "30000/1001", "24000/1001"};
3690 if(!strncmp(arg, "pal-", 4)) {
3693 } else if(!strncmp(arg, "ntsc-", 5)) {
3696 } else if(!strncmp(arg, "film-", 5)) {
3701 /* Calculate FR via float to avoid int overflow */
3702 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3705 } else if((fr == 29970) || (fr == 23976)) {
3708 /* Try to determine PAL/NTSC by peeking in the input files */
3709 if(nb_input_files) {
3711 for(j = 0; j < nb_input_files; j++) {
3712 for(i = 0; i < input_files[j]->nb_streams; i++) {
3713 AVCodecContext *c = &input_files[j]->streams[i]->codec;
3714 if(c->codec_type != CODEC_TYPE_VIDEO)
3716 fr = c->frame_rate * 1000 / c->frame_rate_base;
3720 } else if((fr == 29970) || (fr == 23976)) {
3730 if(verbose && norm >= 0)
3731 printf("Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3735 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3736 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3737 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3741 if(!strcmp(arg, "vcd")) {
3743 opt_video_codec("mpeg1video");
3744 opt_audio_codec("mp2");
3747 opt_frame_size(norm ? "352x240" : "352x288");
3748 opt_frame_rate(frame_rates[norm]);
3749 opt_gop_size(norm ? "18" : "15");
3751 video_bit_rate = 1150000;
3752 video_rc_max_rate = 1150000;
3753 video_rc_min_rate = 1150000;
3754 video_rc_buffer_size = 40*1024*8;
3756 audio_bit_rate = 224000;
3757 audio_sample_rate = 44100;
3759 mux_packet_size= 2324;
3760 mux_rate= 2352 * 75 * 8;
3762 /* We have to offset the PTS, so that it is consistent with the SCR.
3763 SCR starts at 36000, but the first two packs contain only padding
3764 and the first pack from the other stream, respectively, may also have
3765 been written before.
3766 So the real data starts at SCR 36000+3*1200. */
3767 mux_preload= (36000+3*1200) / 90000.0; //0.44
3768 } else if(!strcmp(arg, "svcd")) {
3770 opt_video_codec("mpeg2video");
3771 opt_audio_codec("mp2");
3774 opt_frame_size(norm ? "480x480" : "480x576");
3775 opt_frame_rate(frame_rates[norm]);
3776 opt_gop_size(norm ? "18" : "15");
3778 video_bit_rate = 2040000;
3779 video_rc_max_rate = 2516000;
3780 video_rc_min_rate = 0; //1145000;
3781 video_rc_buffer_size = 224*1024*8;
3782 use_scan_offset = 1;
3784 audio_bit_rate = 224000;
3785 audio_sample_rate = 44100;
3787 mux_packet_size= 2324;
3789 } else if(!strcmp(arg, "dvd")) {
3791 opt_video_codec("mpeg2video");
3792 opt_audio_codec("ac3");
3795 opt_frame_size(norm ? "720x480" : "720x576");
3796 opt_frame_rate(frame_rates[norm]);
3797 opt_gop_size(norm ? "18" : "15");
3799 video_bit_rate = 6000000;
3800 video_rc_max_rate = 9000000;
3801 video_rc_min_rate = 0; //1500000;
3802 video_rc_buffer_size = 224*1024*8;
3804 mux_packet_size= 2048; // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3805 mux_rate = 10080000; // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3807 audio_bit_rate = 448000;
3808 audio_sample_rate = 48000;
3810 } else if(!strcmp(arg, "dv")) {
3814 opt_frame_size(norm ? "720x480" : "720x576");
3815 opt_frame_rate(frame_rates[norm]);
3817 audio_sample_rate = 48000;
3821 fprintf(stderr, "Unknown target: %s\n", arg);
3826 static void show_version(void)
3828 printf("ffmpeg " FFMPEG_VERSION "\n"
3831 avcodec_build(), LIBAVFORMAT_BUILD);
3835 const OptionDef options[] = {
3837 { "L", 0, {(void*)show_license}, "show license" },
3838 { "h", 0, {(void*)show_help}, "show help" },
3839 { "version", 0, {(void*)show_version}, "show version" },
3840 { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3841 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3842 { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3843 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3844 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3845 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream" },
3846 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3847 { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3848 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3849 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3850 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3851 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3852 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3853 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3854 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3855 { "debug", HAS_ARG | OPT_EXPERT, {(void*)opt_debug}, "print specific debug info", "" },
3856 { "vismv", HAS_ARG | OPT_EXPERT, {(void*)opt_vismv}, "visualize motion vectors", "" },
3857 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3858 "add timings for benchmarking" },
3859 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3860 "dump each input packet" },
3861 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3862 "when dumping packets, also dump the payload" },
3863 { "bitexact", OPT_EXPERT, {(void*)opt_bitexact}, "only use bit exact algorithms (for codec testing)" },
3864 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3865 { "loop", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3866 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3867 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3868 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3869 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3870 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3871 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3874 { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
3875 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3876 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3877 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3878 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3879 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3880 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3881 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3882 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3883 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3884 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3885 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3886 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3887 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3888 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3889 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3890 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3891 { "g", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
3892 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3893 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3894 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
3895 { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
3896 { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
3897 { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
3898 { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
3899 { "mbqmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_qmin}, "min macroblock quantiser scale (VBR)", "q" },
3900 { "mbqmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_qmax}, "max macroblock quantiser scale (VBR)", "q" },
3901 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
3902 { "qblur", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
3903 { "qcomp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
3904 { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
3905 { "b_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
3906 { "i_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
3907 { "b_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
3908 { "i_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
3909 { "ibias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ibias}, "intra quant bias", "bias" },
3910 { "pbias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pbias}, "inter quant bias", "bias" },
3911 // { "b_strategy", HAS_ARG | OPT_EXPERT, {(void*)opt_b_strategy}, "dynamic b frame selection strategy", "strategy" },
3912 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3913 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3914 { "bt", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
3915 { "maxrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
3916 { "minrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
3917 { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffer size (in kByte)", "size" },
3918 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3919 { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3921 { "dct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dct_algo}, "set dct algo", "algo" },
3922 { "idct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_idct_algo}, "set idct algo", "algo" },
3923 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
3924 { "mb_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_threshold}, "macroblock threshold", "" },
3925 { "er", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_resilience}, "set error resilience", "n" },
3926 { "ec", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_concealment}, "set error concealment", "bit_mask" },
3927 { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
3928 { "hq", OPT_BOOL, {(void*)&mb_decision}, "activate high quality settings" },
3929 { "mbd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_decision}, "macroblock decision", "mode" },
3930 { "mbcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_cmp}, "macroblock compare function", "cmp function" },
3931 { "ildctcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ildct_cmp}, "ildct compare function", "cmp function" },
3932 { "subcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sub_cmp}, "subpel compare function", "cmp function" },
3933 { "cmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_cmp}, "fullpel compare function", "cmp function" },
3934 { "precmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_cmp}, "pre motion estimation compare function", "cmp function" },
3935 { "preme", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_me}, "pre motion estimation", "" },
3936 { "lumi_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lumi_mask}, "luminance masking", "" },
3937 { "dark_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dark_mask}, "darkness masking", "" },
3938 { "scplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_scplx_mask}, "spatial complexity masking", "" },
3939 { "tcplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_tcplx_mask}, "temporal complexity masking", "" },
3940 { "p_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_p_mask}, "inter masking", "" },
3941 { "4mv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_4mv}, "use four motion vector by macroblock (MPEG4)" },
3942 { "obmc", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_obmc}, "use overlapped block motion compensation (h263+)" },
3943 { "lf", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_loop}, "use loop filter (h263+)" },
3944 { "part", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_part}, "use data partitioning (MPEG4)" },
3945 { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
3946 { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
3947 { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
3948 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3949 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3950 "use same video quality as source (implies VBR)" },
3951 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3952 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3953 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3954 "deinterlace pictures" },
3955 { "ildct", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_dct},
3956 "force interlaced dct support in encoder (MPEG2/MPEG4)" },
3957 { "ilme", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_me},
3958 "force interlaced me support in encoder (MPEG2/MPEG4)" },
3959 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3960 { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
3961 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3962 { "aic", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aic}, "enable Advanced intra coding (h263+)" },
3963 { "aiv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aiv}, "enable Alternative inter vlc (h263+)" },
3964 { "umv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_umv}, "enable Unlimited Motion Vector (h263+)" },
3965 { "ssm", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_ss}, "enable Slice Structured mode (h263+)" },
3966 { "alt", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_alt_scan}, "enable alternate scantable (MPEG2/MPEG4)" },
3967 { "qprd", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qprd}, "" },
3968 { "cbp", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_cbprd}, "" },
3969 { "trell", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_trell}, "enable trellis quantization" },
3970 { "cgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&closed_gop}, "closed gop" },
3971 { "sgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&strict_gop}, "strict gop" },
3972 { "scan_offset", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_scan_offset}, "enable SVCD Scan Offset placeholder" },
3973 { "qpel", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qpel}, "enable 1/4-pel" },
3974 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3975 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3976 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3977 { "nr", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_noise_reduction}, "noise reduction", "" },
3978 { "qns", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qns}, "quantization noise shaping", "" },
3979 { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
3980 { "me_range", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_range}, "limit motion vectors range (1023 for DivX player)", "range" },
3981 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3982 { "coder", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&coder}, "coder type", "" },
3983 { "context", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&context}, "context model", "" },
3984 { "pred", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&predictor}, "prediction method", "" },
3985 { "vprofile", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_profile}, "profile", "" },
3986 { "vlevel", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_level}, "level", "" },
3987 { "nssew", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&nsse_weight}, "weight", "" },
3988 { "subq", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&subpel_quality}, "", "" },
3989 { "lowres", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&lowres}, "", "" },
3990 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3991 { "skip_threshold", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_threshold}, "frame skip threshold", "threshold" },
3992 { "skip_factor", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_factor}, "frame skip factor", "factor" },
3993 { "skip_exp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_exp}, "frame skip exponent", "exponent" },
3994 { "skip_cmp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_cmp}, "frame skip compare function", "compare function" },
3997 { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
3998 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3999 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4000 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4001 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4002 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4005 { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
4006 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4007 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4008 { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
4010 /* G.2 grab options */
4011 { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
4012 { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
4015 { "muxrate", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_rate}, "set mux rate", "rate" },
4016 { "packetsize", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_packet_size}, "set packet size", "size" },
4017 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4018 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4022 static void show_banner(void)
4024 printf("ffmpeg version " FFMPEG_VERSION ", build %d, Copyright (c) 2000-2004 Fabrice Bellard\n",
4026 printf(" configuration: %s\n", FFMPEG_CONFIGURATION);
4027 printf(" built on " __DATE__ " " __TIME__);
4029 printf(", gcc: %s\n", __VERSION__);
4031 printf(", using a non-gcc compiler\n");
4035 static void show_license(void)
4040 "This program is free software; you can redistribute it and/or modify\n"
4041 "it under the terms of the GNU General Public License as published by\n"
4042 "the Free Software Foundation; either version 2 of the License, or\n"
4043 "(at your option) any later version.\n"
4045 "This program is distributed in the hope that it will be useful,\n"
4046 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4047 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
4048 "GNU General Public License for more details.\n"
4050 "You should have received a copy of the GNU General Public License\n"
4051 "along with this program; if not, write to the Free Software\n"
4052 "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n"
4056 "This library is free software; you can redistribute it and/or\n"
4057 "modify it under the terms of the GNU Lesser General Public\n"
4058 "License as published by the Free Software Foundation; either\n"
4059 "version 2 of the License, or (at your option) any later version.\n"
4061 "This library is distributed in the hope that it will be useful,\n"
4062 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4063 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
4064 "Lesser General Public License for more details.\n"
4066 "You should have received a copy of the GNU Lesser General Public\n"
4067 "License along with this library; if not, write to the Free Software\n"
4068 "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n"
4074 static void show_help(void)
4077 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
4078 "Hyper fast Audio and Video encoder\n");
4080 show_help_options(options, "Main options:\n",
4081 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
4082 show_help_options(options, "\nVideo options:\n",
4083 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4085 show_help_options(options, "\nAdvanced Video options:\n",
4086 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4087 OPT_VIDEO | OPT_EXPERT);
4088 show_help_options(options, "\nAudio options:\n",
4089 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4091 show_help_options(options, "\nAdvanced Audio options:\n",
4092 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4093 OPT_AUDIO | OPT_EXPERT);
4094 show_help_options(options, "\nAudio/Video grab options:\n",
4097 show_help_options(options, "\nAdvanced options:\n",
4098 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4103 void parse_arg_file(const char *filename)
4105 opt_output_file(filename);
4108 int main(int argc, char **argv)
4121 parse_options(argc, argv, options);
4123 /* file converter / grab */
4124 if (nb_output_files <= 0) {
4125 fprintf(stderr, "Must supply at least one output file\n");
4129 if (nb_input_files == 0) {
4135 av_encode(output_files, nb_output_files, input_files, nb_input_files,
4136 stream_maps, nb_stream_maps);
4137 ti = getutime() - ti;
4139 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4143 for(i=0;i<nb_output_files;i++) {
4144 /* maybe av_close_output_file ??? */
4145 AVFormatContext *s = output_files[i];
4147 if (!(s->oformat->flags & AVFMT_NOFILE))
4149 for(j=0;j<s->nb_streams;j++)
4150 av_free(s->streams[j]);
4153 for(i=0;i<nb_input_files;i++)
4154 av_close_input_file(input_files[i]);
4159 av_free(intra_matrix);
4161 av_free(inter_matrix);
4163 #ifdef POWERPC_PERFORMANCE_REPORT
4164 extern void powerpc_display_perf_report(void);
4165 powerpc_display_perf_report();
4166 #endif /* POWERPC_PERFORMANCE_REPORT */
4168 #ifndef CONFIG_WIN32
4169 if (received_sigterm) {
4171 "Received signal %d: terminating.\n",
4172 (int) received_sigterm);
4176 exit(0); /* not all OS-es handle main() return value */