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
44 #if !defined(INFINITY) && defined(HUGE_VAL)
45 #define INFINITY HUGE_VAL
48 /* select an input stream for an output stream */
49 typedef struct AVStreamMap {
54 /** select an input file for an output file */
55 typedef struct AVMetaDataMap {
60 extern const OptionDef options[];
62 static void show_help(void);
63 static void show_license(void);
67 static AVFormatContext *input_files[MAX_FILES];
68 static int64_t input_files_ts_offset[MAX_FILES];
69 static int nb_input_files = 0;
71 static AVFormatContext *output_files[MAX_FILES];
72 static int nb_output_files = 0;
74 static AVStreamMap stream_maps[MAX_FILES];
75 static int nb_stream_maps;
77 static AVMetaDataMap meta_data_maps[MAX_FILES];
78 static int nb_meta_data_maps;
80 static AVInputFormat *file_iformat;
81 static AVOutputFormat *file_oformat;
82 static AVImageFormat *image_format;
83 static int frame_width = 160;
84 static int frame_height = 128;
85 static float frame_aspect_ratio = 0;
86 static enum PixelFormat frame_pix_fmt = PIX_FMT_YUV420P;
87 static int frame_padtop = 0;
88 static int frame_padbottom = 0;
89 static int frame_padleft = 0;
90 static int frame_padright = 0;
91 static int padcolor[3] = {16,128,128}; /* default to black */
92 static int frame_topBand = 0;
93 static int frame_bottomBand = 0;
94 static int frame_leftBand = 0;
95 static int frame_rightBand = 0;
96 static int frame_rate = 25;
97 static int frame_rate_base = 1;
98 static int video_bit_rate = 200*1000;
99 static int video_bit_rate_tolerance = 4000*1000;
100 static float video_qscale = 0;
101 static int video_qmin = 2;
102 static int video_qmax = 31;
103 static int video_lmin = 2*FF_QP2LAMBDA;
104 static int video_lmax = 31*FF_QP2LAMBDA;
105 static int video_mb_qmin = 2;
106 static int video_mb_qmax = 31;
107 static int video_qdiff = 3;
108 static float video_qblur = 0.5;
109 static float video_qcomp = 0.5;
110 static uint16_t *intra_matrix = NULL;
111 static uint16_t *inter_matrix = NULL;
112 #if 0 //experimental, (can be removed)
113 static float video_rc_qsquish=1.0;
114 static float video_rc_qmod_amp=0;
115 static int video_rc_qmod_freq=0;
117 static char *video_rc_override_string=NULL;
118 static char *video_rc_eq="tex^qComp";
119 static int video_rc_buffer_size=0;
120 static float video_rc_buffer_aggressivity=1.0;
121 static int video_rc_max_rate=0;
122 static int video_rc_min_rate=0;
123 static float video_rc_initial_cplx=0;
124 static float video_b_qfactor = 1.25;
125 static float video_b_qoffset = 1.25;
126 static float video_i_qfactor = -0.8;
127 static float video_i_qoffset = 0.0;
128 static int video_intra_quant_bias= FF_DEFAULT_QUANT_BIAS;
129 static int video_inter_quant_bias= FF_DEFAULT_QUANT_BIAS;
130 static int me_method = ME_EPZS;
131 static int video_disable = 0;
132 static int video_codec_id = CODEC_ID_NONE;
133 static int same_quality = 0;
134 static int b_frames = 0;
135 static int mb_decision = FF_MB_DECISION_SIMPLE;
136 static int ildct_cmp = FF_CMP_VSAD;
137 static int mb_cmp = FF_CMP_SAD;
138 static int sub_cmp = FF_CMP_SAD;
139 static int cmp = FF_CMP_SAD;
140 static int pre_cmp = FF_CMP_SAD;
141 static int pre_me = 0;
142 static float lumi_mask = 0;
143 static float dark_mask = 0;
144 static float scplx_mask = 0;
145 static float tcplx_mask = 0;
146 static float p_mask = 0;
147 static int use_4mv = 0;
148 static int use_obmc = 0;
149 static int use_loop = 0;
150 static int use_aic = 0;
151 static int use_aiv = 0;
152 static int use_umv = 0;
153 static int use_ss = 0;
154 static int use_alt_scan = 0;
155 static int use_trell = 0;
156 static int use_scan_offset = 0;
157 static int use_qpel = 0;
158 static int use_qprd = 0;
159 static int use_cbprd = 0;
161 static int closed_gop = 0;
162 static int do_deinterlace = 0;
163 static int do_interlace_dct = 0;
164 static int do_interlace_me = 0;
165 static int workaround_bugs = FF_BUG_AUTODETECT;
166 static int error_resilience = 2;
167 static int error_concealment = 3;
168 static int dct_algo = 0;
169 static int idct_algo = 0;
170 static int use_part = 0;
171 static int packet_size = 0;
172 static int error_rate = 0;
173 static int strict = 0;
174 static int top_field_first = -1;
175 static int noise_reduction = 0;
176 static int sc_threshold = 0;
177 static int debug = 0;
178 static int debug_mv = 0;
179 static int me_threshold = 0;
180 static int mb_threshold = 0;
181 static int intra_dc_precision = 8;
182 static int coder = 0;
183 static int context = 0;
184 static int predictor = 0;
185 extern int loop_input; /* currently a hack */
187 static int gop_size = 12;
188 static int intra_only = 0;
189 static int audio_sample_rate = 44100;
190 static int audio_bit_rate = 64000;
191 static int audio_disable = 0;
192 static int audio_channels = 1;
193 static int audio_codec_id = CODEC_ID_NONE;
195 static int64_t recording_time = 0;
196 static int64_t start_time = 0;
197 static int64_t rec_timestamp = 0;
198 static int64_t input_ts_offset = 0;
199 static int file_overwrite = 0;
200 static char *str_title = NULL;
201 static char *str_author = NULL;
202 static char *str_copyright = NULL;
203 static char *str_comment = NULL;
204 static int do_benchmark = 0;
205 static int do_hex_dump = 0;
206 static int do_pkt_dump = 0;
207 static int do_psnr = 0;
208 static int do_vstats = 0;
209 static int do_pass = 0;
210 static int bitexact = 0;
211 static char *pass_logfilename = NULL;
212 static int audio_stream_copy = 0;
213 static int video_stream_copy = 0;
214 static int video_sync_method= 1;
215 static int audio_sync_method= 0;
216 static int copy_ts= 0;
218 static int rate_emu = 0;
220 static char *video_grab_format = "video4linux";
221 static char *video_device = NULL;
222 static int video_channel = 0;
223 static char *video_standard = "ntsc";
225 static char *audio_grab_format = "audio_device";
226 static char *audio_device = NULL;
228 static int using_stdin = 0;
229 static int using_vhook = 0;
230 static int verbose = 1;
231 static int thread_count= 1;
232 static int q_pressed = 0;
233 static int me_range = 0;
234 static int64_t video_size = 0;
235 static int64_t audio_size = 0;
236 static int64_t extra_size = 0;
237 static int nb_frames_dup = 0;
238 static int nb_frames_drop = 0;
239 static int input_sync;
241 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
243 typedef struct AVOutputStream {
244 int file_index; /* file index */
245 int index; /* stream index in the output file */
246 int source_index; /* AVInputStream index */
247 AVStream *st; /* stream in the output file */
248 int encoding_needed; /* true if encoding needed for this stream */
250 /* input pts and corresponding output pts
252 double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
253 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
255 int video_resample; /* video_resample and video_crop are mutually exclusive */
256 AVFrame pict_tmp; /* temporary image for resampling */
257 ImgReSampleContext *img_resample_ctx; /* for image resampling */
259 int video_crop; /* video_resample and video_crop are mutually exclusive */
260 int topBand; /* cropping area sizes */
263 int video_pad; /* video_resample and video_pad are mutually exclusive */
264 int padtop; /* padding area sizes */
271 ReSampleContext *resample; /* for audio resampling */
272 FifoBuffer fifo; /* for compression: one audio fifo per codec */
276 typedef struct AVInputStream {
280 int discard; /* true if stream data should be discarded */
281 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
282 int64_t sample_index; /* current sample */
284 int64_t start; /* time when read started */
285 unsigned long frame; /* current frame */
286 int64_t next_pts; /* synthetic pts for cases where pkt.pts
288 int64_t pts; /* current pts */
289 int is_start; /* is 1 at the start and after a discontinuity */
292 typedef struct AVInputFile {
293 int eof_reached; /* true if eof reached */
294 int ist_index; /* index of first stream in ist_table */
295 int buffer_size; /* current total buffer size */
296 int buffer_size_max; /* buffer size at which we consider we can stop
298 int nb_streams; /* nb streams we are aware of */
303 /* init terminal so that we can grab keys */
304 static struct termios oldtty;
306 static void term_exit(void)
308 tcsetattr (0, TCSANOW, &oldtty);
311 static volatile sig_atomic_t received_sigterm = 0;
314 sigterm_handler(int sig)
316 received_sigterm = sig;
320 static void term_init(void)
327 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
328 |INLCR|IGNCR|ICRNL|IXON);
329 tty.c_oflag |= OPOST;
330 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
331 tty.c_cflag &= ~(CSIZE|PARENB);
336 tcsetattr (0, TCSANOW, &tty);
338 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
339 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
340 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
342 register a function to be called at normal program termination
345 #ifdef CONFIG_BEOS_NETSERVER
346 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
350 /* read a key without blocking */
351 static int read_key(void)
355 #ifndef CONFIG_BEOS_NETSERVER
363 n = select(1, &rfds, NULL, NULL, &tv);
375 static int decode_interrupt_cb(void)
377 return q_pressed || (q_pressed = read_key() == 'q');
382 static volatile int received_sigterm = 0;
384 /* no interactive support */
385 static void term_exit(void)
389 static void term_init(void)
393 static int read_key(void)
400 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
405 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
408 /* copy stream format */
409 s->nb_streams = ic->nb_streams;
410 for(i=0;i<ic->nb_streams;i++) {
413 st = av_mallocz(sizeof(AVStream));
414 memcpy(st, ic->streams[i], sizeof(AVStream));
418 av_close_input_file(ic);
422 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
424 static void do_audio_out(AVFormatContext *s,
427 unsigned char *buf, int size)
430 static uint8_t *audio_buf = NULL;
431 static uint8_t *audio_out = NULL;
432 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
434 int size_out, frame_bytes, ret;
435 AVCodecContext *enc= &ost->st->codec;
437 /* SC: dynamic allocation of buffers */
439 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
441 audio_out = av_malloc(audio_out_size);
442 if (!audio_buf || !audio_out)
443 return; /* Should signal an error ! */
445 if(audio_sync_method){
446 double delta = ost->sync_ipts * enc->sample_rate - ost->sync_opts
447 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2);
448 double idelta= delta*ist->st->codec.sample_rate / enc->sample_rate;
449 int byte_delta= ((int)idelta)*2*ist->st->codec.channels;
451 //FIXME resample delay
452 if(fabs(delta) > 50){
455 byte_delta= FFMAX(byte_delta, -size);
459 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
464 static uint8_t *input_tmp= NULL;
465 input_tmp= av_realloc(input_tmp, byte_delta + size);
467 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
470 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
472 memset(input_tmp, 0, byte_delta);
473 memcpy(input_tmp + byte_delta, buf, size);
477 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
479 }else if(audio_sync_method>1){
480 int comp= clip(delta, -audio_sync_method, audio_sync_method);
481 assert(ost->audio_resample);
483 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
484 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));
485 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
489 ost->sync_opts= lrintf(ost->sync_ipts * enc->sample_rate)
490 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2); //FIXME wrong
492 if (ost->audio_resample) {
494 size_out = audio_resample(ost->resample,
495 (short *)buftmp, (short *)buf,
496 size / (ist->st->codec.channels * 2));
497 size_out = size_out * enc->channels * 2;
503 /* now encode as many frames as possible */
504 if (enc->frame_size > 1) {
505 /* output resampled raw samples */
506 fifo_write(&ost->fifo, buftmp, size_out,
509 frame_bytes = enc->frame_size * 2 * enc->channels;
511 while (fifo_read(&ost->fifo, audio_buf, frame_bytes,
512 &ost->fifo.rptr) == 0) {
514 av_init_packet(&pkt);
516 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
519 pkt.stream_index= ost->index;
523 pkt.pts= enc->coded_frame->pts;
524 pkt.flags |= PKT_FLAG_KEY;
525 av_interleaved_write_frame(s, &pkt);
527 ost->sync_opts += enc->frame_size;
531 av_init_packet(&pkt);
533 ost->sync_opts += size_out / (2 * enc->channels);
535 /* output a pcm frame */
536 /* XXX: change encoding codec API to avoid this ? */
537 switch(enc->codec->id) {
538 case CODEC_ID_PCM_S16LE:
539 case CODEC_ID_PCM_S16BE:
540 case CODEC_ID_PCM_U16LE:
541 case CODEC_ID_PCM_U16BE:
544 size_out = size_out >> 1;
547 ret = avcodec_encode_audio(enc, audio_out, size_out,
550 pkt.stream_index= ost->index;
554 pkt.pts= enc->coded_frame->pts;
555 pkt.flags |= PKT_FLAG_KEY;
556 av_interleaved_write_frame(s, &pkt);
560 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
564 AVPicture picture_tmp;
567 dec = &ist->st->codec;
569 /* deinterlace : must be done before any resize */
570 if (do_deinterlace || using_vhook) {
573 /* create temporary picture */
574 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
575 buf = av_malloc(size);
579 picture2 = &picture_tmp;
580 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
583 if(avpicture_deinterlace(picture2, picture,
584 dec->pix_fmt, dec->width, dec->height) < 0) {
585 /* if error, do not deinterlace */
591 if (img_convert(picture2, dec->pix_fmt, picture,
592 dec->pix_fmt, dec->width, dec->height) < 0) {
593 /* if error, do not copy */
603 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
605 if (picture != picture2)
606 *picture = *picture2;
610 /* we begin to correct av delay at this threshold */
611 #define AV_DELAY_MAX 0.100
614 /* Expects img to be yuv420 */
615 static void fill_pad_region(AVPicture* img, int height, int width,
616 int padtop, int padbottom, int padleft, int padright, int *color) {
621 for (i = 0; i < 3; i++) {
622 shift = (i == 0) ? 0 : 1;
624 if (padtop || padleft) {
625 memset(img->data[i], color[i], (((img->linesize[i] * padtop) +
629 if (padleft || padright) {
630 optr = img->data[i] + (img->linesize[i] * (padtop >> shift)) +
631 (img->linesize[i] - (padright >> shift));
633 for (y = 0; y < ((height - (padtop + padbottom)) >> shift); y++) {
634 memset(optr, color[i], (padleft + padright) >> shift);
635 optr += img->linesize[i];
640 optr = img->data[i] + (img->linesize[i] * ((height - padbottom) >> shift));
641 memset(optr, color[i], ((img->linesize[i] * padbottom) >> shift));
646 static uint8_t *bit_buffer= NULL;
648 static void do_video_out(AVFormatContext *s,
654 int nb_frames, i, ret;
655 AVFrame *final_picture, *formatted_picture;
656 AVFrame picture_format_temp, picture_crop_temp;
657 uint8_t *buf = NULL, *buf1 = NULL;
658 AVCodecContext *enc, *dec;
659 enum PixelFormat target_pixfmt;
661 #define VIDEO_BUFFER_SIZE (1024*1024)
663 avcodec_get_frame_defaults(&picture_format_temp);
664 avcodec_get_frame_defaults(&picture_crop_temp);
666 enc = &ost->st->codec;
667 dec = &ist->st->codec;
669 /* by default, we output a single frame */
674 if(video_sync_method){
676 vdelta = ost->sync_ipts * enc->frame_rate / enc->frame_rate_base - ost->sync_opts;
677 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
680 else if (vdelta > 1.1)
682 //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);
686 fprintf(stderr, "*** drop!\n");
687 }else if (nb_frames == 2) {
690 fprintf(stderr, "*** dup!\n");
693 ost->sync_opts= lrintf(ost->sync_ipts * enc->frame_rate / enc->frame_rate_base);
698 /* convert pixel format if needed */
699 target_pixfmt = ost->video_resample || ost->video_pad
700 ? PIX_FMT_YUV420P : enc->pix_fmt;
701 if (dec->pix_fmt != target_pixfmt) {
704 /* create temporary picture */
705 size = avpicture_get_size(target_pixfmt, dec->width, dec->height);
706 buf = av_malloc(size);
709 formatted_picture = &picture_format_temp;
710 avpicture_fill((AVPicture*)formatted_picture, buf, target_pixfmt, dec->width, dec->height);
712 if (img_convert((AVPicture*)formatted_picture, target_pixfmt,
713 (AVPicture *)in_picture, dec->pix_fmt,
714 dec->width, dec->height) < 0) {
717 fprintf(stderr, "pixel format conversion not handled\n");
722 formatted_picture = in_picture;
725 /* XXX: resampling could be done before raw format conversion in
726 some cases to go faster */
727 /* XXX: only works for YUV420P */
728 if (ost->video_resample) {
729 final_picture = &ost->pict_tmp;
730 img_resample(ost->img_resample_ctx, (AVPicture*)final_picture, (AVPicture*)formatted_picture);
732 if (ost->padtop || ost->padbottom || ost->padleft || ost->padright) {
733 fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
734 ost->padtop, ost->padbottom, ost->padleft, ost->padright,
738 if (enc->pix_fmt != PIX_FMT_YUV420P) {
742 /* create temporary picture */
743 size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
744 buf = av_malloc(size);
747 final_picture = &picture_format_temp;
748 avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
750 if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
751 (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
752 enc->width, enc->height) < 0) {
755 fprintf(stderr, "pixel format conversion not handled\n");
760 } else if (ost->video_crop) {
761 picture_crop_temp.data[0] = formatted_picture->data[0] +
762 (ost->topBand * formatted_picture->linesize[0]) + ost->leftBand;
764 picture_crop_temp.data[1] = formatted_picture->data[1] +
765 ((ost->topBand >> 1) * formatted_picture->linesize[1]) +
766 (ost->leftBand >> 1);
768 picture_crop_temp.data[2] = formatted_picture->data[2] +
769 ((ost->topBand >> 1) * formatted_picture->linesize[2]) +
770 (ost->leftBand >> 1);
772 picture_crop_temp.linesize[0] = formatted_picture->linesize[0];
773 picture_crop_temp.linesize[1] = formatted_picture->linesize[1];
774 picture_crop_temp.linesize[2] = formatted_picture->linesize[2];
775 final_picture = &picture_crop_temp;
776 } else if (ost->video_pad) {
777 final_picture = &ost->pict_tmp;
779 for (i = 0; i < 3; i++) {
780 uint8_t *optr, *iptr;
781 int shift = (i == 0) ? 0 : 1;
784 /* set offset to start writing image into */
785 optr = final_picture->data[i] + (((final_picture->linesize[i] *
786 ost->padtop) + ost->padleft) >> shift);
787 iptr = formatted_picture->data[i];
789 yheight = (enc->height - ost->padtop - ost->padbottom) >> shift;
790 for (y = 0; y < yheight; y++) {
791 /* copy unpadded image row into padded image row */
792 memcpy(optr, iptr, formatted_picture->linesize[i]);
793 optr += final_picture->linesize[i];
794 iptr += formatted_picture->linesize[i];
798 fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
799 ost->padtop, ost->padbottom, ost->padleft, ost->padright,
802 if (enc->pix_fmt != PIX_FMT_YUV420P) {
806 /* create temporary picture */
807 size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
808 buf = av_malloc(size);
811 final_picture = &picture_format_temp;
812 avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
814 if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
815 (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
816 enc->width, enc->height) < 0) {
819 fprintf(stderr, "pixel format conversion not handled\n");
825 final_picture = formatted_picture;
827 /* duplicates frame if needed */
828 for(i=0;i<nb_frames;i++) {
830 av_init_packet(&pkt);
831 pkt.stream_index= ost->index;
833 if (s->oformat->flags & AVFMT_RAWPICTURE) {
834 /* raw pictures are written as AVPicture structure to
835 avoid any copies. We support temorarily the older
837 AVFrame* old_frame = enc->coded_frame;
838 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
839 pkt.data= (uint8_t *)final_picture;
840 pkt.size= sizeof(AVPicture);
842 pkt.pts= dec->coded_frame->pts;
843 if(dec->coded_frame && dec->coded_frame->key_frame)
844 pkt.flags |= PKT_FLAG_KEY;
846 av_interleaved_write_frame(s, &pkt);
847 enc->coded_frame = old_frame;
851 big_picture= *final_picture;
852 /* better than nothing: use input picture interlaced
854 big_picture.interlaced_frame = in_picture->interlaced_frame;
855 if(do_interlace_me || do_interlace_dct){
856 if(top_field_first == -1)
857 big_picture.top_field_first = in_picture->top_field_first;
859 big_picture.top_field_first = top_field_first;
862 /* handles sameq here. This is not correct because it may
863 not be a global option */
865 big_picture.quality = ist->st->quality;
867 big_picture.quality = ost->st->quality;
869 big_picture.pict_type = 0;
870 // big_picture.pts = AV_NOPTS_VALUE;
871 big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->frame_rate_base, enc->frame_rate);
872 //av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
873 ret = avcodec_encode_video(enc,
874 bit_buffer, VIDEO_BUFFER_SIZE,
876 //enc->frame_number = enc->real_pict_num;
878 pkt.data= bit_buffer;
881 pkt.pts= enc->coded_frame->pts;
882 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n",
883 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->frame_rate, AV_TIME_BASE*(int64_t)enc->frame_rate_base) : -1,
884 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->frame_rate, AV_TIME_BASE*(int64_t)enc->frame_rate_base) : -1);*/
886 if(enc->coded_frame && enc->coded_frame->key_frame)
887 pkt.flags |= PKT_FLAG_KEY;
888 av_interleaved_write_frame(s, &pkt);
890 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
891 // enc->frame_number-1, enc->real_pict_num, ret,
893 /* if two pass, output log */
894 if (ost->logfile && enc->stats_out) {
895 fprintf(ost->logfile, "%s", enc->stats_out);
907 static double psnr(double d){
908 if(d==0) return INFINITY;
909 return -10.0*log(d)/log(10.0);
912 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
915 static FILE *fvstats=NULL;
922 double ti1, bitrate, avg_bitrate;
926 today = localtime(&today2);
927 sprintf(filename, "vstats_%02d%02d%02d.log", today->tm_hour,
930 fvstats = fopen(filename,"w");
938 enc = &ost->st->codec;
939 if (enc->codec_type == CODEC_TYPE_VIDEO) {
940 frame_number = ost->frame_number;
941 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
942 if (enc->flags&CODEC_FLAG_PSNR)
943 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
945 fprintf(fvstats,"f_size= %6d ", frame_size);
946 /* compute pts value */
947 ti1 = (double)ost->sync_opts *enc->frame_rate_base / enc->frame_rate;
951 bitrate = (double)(frame_size * 8) * enc->frame_rate / enc->frame_rate_base / 1000.0;
952 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
953 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
954 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
955 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
959 static void print_report(AVFormatContext **output_files,
960 AVOutputStream **ost_table, int nb_ostreams,
965 AVFormatContext *oc, *os;
968 int frame_number, vid, i;
969 double bitrate, ti1, pts;
970 static int64_t last_time = -1;
972 if (!is_last_report) {
974 /* display the report every 0.5 seconds */
975 cur_time = av_gettime();
976 if (last_time == -1) {
977 last_time = cur_time;
980 if ((cur_time - last_time) < 500000)
982 last_time = cur_time;
986 oc = output_files[0];
988 total_size = url_ftell(&oc->pb);
993 for(i=0;i<nb_ostreams;i++) {
995 os = output_files[ost->file_index];
996 enc = &ost->st->codec;
997 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
998 sprintf(buf + strlen(buf), "q=%2.1f ",
999 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1001 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1002 frame_number = ost->frame_number;
1003 sprintf(buf + strlen(buf), "frame=%5d q=%2.1f ",
1004 frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : 0);
1006 sprintf(buf + strlen(buf), "L");
1007 if (enc->flags&CODEC_FLAG_PSNR){
1009 double error, error_sum=0;
1010 double scale, scale_sum=0;
1011 char type[3]= {'Y','U','V'};
1012 sprintf(buf + strlen(buf), "PSNR=");
1015 error= enc->error[j];
1016 scale= enc->width*enc->height*255.0*255.0*frame_number;
1018 error= enc->coded_frame->error[j];
1019 scale= enc->width*enc->height*255.0*255.0;
1024 sprintf(buf + strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1026 sprintf(buf + strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1030 /* compute min output value */
1031 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1032 if ((pts < ti1) && (pts > 0))
1038 if (verbose || is_last_report) {
1039 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1041 sprintf(buf + strlen(buf),
1042 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1043 (double)total_size / 1024, ti1, bitrate);
1046 sprintf(buf + strlen(buf), " dup=%d drop=%d",
1047 nb_frames_dup, nb_frames_drop);
1050 fprintf(stderr, "%s \r", buf);
1055 if (is_last_report && verbose >= 0){
1056 int64_t raw= audio_size + video_size + extra_size;
1057 fprintf(stderr, "\n");
1058 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1062 100.0*(total_size - raw)/raw
1067 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1068 static int output_packet(AVInputStream *ist, int ist_index,
1069 AVOutputStream **ost_table, int nb_ostreams,
1070 const AVPacket *pkt)
1072 AVFormatContext *os;
1073 AVOutputStream *ost;
1077 int data_size, got_picture;
1079 short samples[pkt && pkt->size > AVCODEC_MAX_AUDIO_FRAME_SIZE/2 ? pkt->size : AVCODEC_MAX_AUDIO_FRAME_SIZE/2];
1080 void *buffer_to_free;
1082 if (pkt && pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1083 ist->next_pts = ist->pts = pkt->dts;
1085 assert(ist->pts == ist->next_pts);
1099 /* decode the packet if needed */
1100 data_buf = NULL; /* fail safe */
1102 if (ist->decoding_needed) {
1103 switch(ist->st->codec.codec_type) {
1104 case CODEC_TYPE_AUDIO:
1105 /* XXX: could avoid copy if PCM 16 bits with same
1106 endianness as CPU */
1107 ret = avcodec_decode_audio(&ist->st->codec, samples, &data_size,
1113 /* Some bug in mpeg audio decoder gives */
1114 /* data_size < 0, it seems they are overflows */
1115 if (data_size <= 0) {
1116 /* no audio frame */
1119 data_buf = (uint8_t *)samples;
1120 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1121 (ist->st->codec.sample_rate * ist->st->codec.channels);
1123 case CODEC_TYPE_VIDEO:
1124 data_size = (ist->st->codec.width * ist->st->codec.height * 3) / 2;
1125 /* XXX: allocate picture correctly */
1126 avcodec_get_frame_defaults(&picture);
1128 ret = avcodec_decode_video(&ist->st->codec,
1129 &picture, &got_picture, ptr, len);
1130 ist->st->quality= picture.quality;
1134 /* no picture yet */
1135 goto discard_packet;
1137 if (ist->st->codec.frame_rate_base != 0) {
1138 ist->next_pts += ((int64_t)AV_TIME_BASE *
1139 ist->st->codec.frame_rate_base) /
1140 ist->st->codec.frame_rate;
1154 buffer_to_free = NULL;
1155 if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO) {
1156 pre_process_video_frame(ist, (AVPicture *)&picture,
1160 /* frame rate emulation */
1161 if (ist->st->codec.rate_emu) {
1162 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec.frame_rate_base, 1000000, ist->st->codec.frame_rate);
1163 int64_t now = av_gettime() - ist->start;
1171 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1172 is the one of the next displayed one */
1173 /* XXX: add mpeg4 too ? */
1174 if (ist->st->codec.codec_id == CODEC_ID_MPEG1VIDEO) {
1175 if (ist->st->codec.pict_type != B_TYPE) {
1177 tmp = ist->last_ip_pts;
1178 ist->last_ip_pts = ist->frac_pts.val;
1179 ist->frac_pts.val = tmp;
1183 /* if output time reached then transcode raw format,
1184 encode packets and output them */
1185 if (start_time == 0 || ist->pts >= start_time)
1186 for(i=0;i<nb_ostreams;i++) {
1190 if (ost->source_index == ist_index) {
1191 os = output_files[ost->file_index];
1194 printf("%d: got pts=%0.3f %0.3f\n", i,
1195 (double)pkt->pts / AV_TIME_BASE,
1196 ((double)ist->pts / AV_TIME_BASE) -
1197 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1199 /* set the input output pts pairs */
1200 ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index])/ AV_TIME_BASE;
1202 if (ost->encoding_needed) {
1203 switch(ost->st->codec.codec_type) {
1204 case CODEC_TYPE_AUDIO:
1205 do_audio_out(os, ost, ist, data_buf, data_size);
1207 case CODEC_TYPE_VIDEO:
1208 /* find an audio stream for synchro */
1211 AVOutputStream *audio_sync, *ost1;
1213 for(i=0;i<nb_ostreams;i++) {
1214 ost1 = ost_table[i];
1215 if (ost1->file_index == ost->file_index &&
1216 ost1->st->codec.codec_type == CODEC_TYPE_AUDIO) {
1222 do_video_out(os, ost, ist, &picture, &frame_size);
1223 video_size += frame_size;
1224 if (do_vstats && frame_size)
1225 do_video_stats(os, ost, frame_size);
1232 AVFrame avframe; //FIXME/XXX remove this
1234 av_init_packet(&opkt);
1236 /* no reencoding needed : output the packet directly */
1237 /* force the input stream PTS */
1239 avcodec_get_frame_defaults(&avframe);
1240 ost->st->codec.coded_frame= &avframe;
1241 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1243 if(ost->st->codec.codec_type == CODEC_TYPE_AUDIO)
1244 audio_size += data_size;
1245 else if (ost->st->codec.codec_type == CODEC_TYPE_VIDEO)
1246 video_size += data_size;
1248 opkt.stream_index= ost->index;
1249 opkt.data= data_buf;
1250 opkt.size= data_size;
1251 opkt.pts= pkt->pts + input_files_ts_offset[ist->file_index];
1252 opkt.dts= pkt->dts + input_files_ts_offset[ist->file_index];
1253 opkt.flags= pkt->flags;
1255 av_interleaved_write_frame(os, &opkt);
1256 ost->st->codec.frame_number++;
1257 ost->frame_number++;
1261 av_free(buffer_to_free);
1267 for(i=0;i<nb_ostreams;i++) {
1269 if (ost->source_index == ist_index) {
1270 AVCodecContext *enc= &ost->st->codec;
1271 os = output_files[ost->file_index];
1273 if(ost->st->codec.codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1275 if(ost->st->codec.codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1278 if (ost->encoding_needed) {
1281 av_init_packet(&pkt);
1282 pkt.stream_index= ost->index;
1284 switch(ost->st->codec.codec_type) {
1285 case CODEC_TYPE_AUDIO:
1286 ret = avcodec_encode_audio(enc, bit_buffer, VIDEO_BUFFER_SIZE, NULL);
1288 pkt.flags |= PKT_FLAG_KEY;
1290 case CODEC_TYPE_VIDEO:
1291 ret = avcodec_encode_video(enc, bit_buffer, VIDEO_BUFFER_SIZE, NULL);
1293 if(enc->coded_frame && enc->coded_frame->key_frame)
1294 pkt.flags |= PKT_FLAG_KEY;
1295 if (ost->logfile && enc->stats_out) {
1296 fprintf(ost->logfile, "%s", enc->stats_out);
1305 pkt.data= bit_buffer;
1307 if(enc->coded_frame)
1308 pkt.pts= enc->coded_frame->pts;
1309 av_interleaved_write_frame(os, &pkt);
1323 * The following code is the main loop of the file converter
1325 static int av_encode(AVFormatContext **output_files,
1326 int nb_output_files,
1327 AVFormatContext **input_files,
1329 AVStreamMap *stream_maps, int nb_stream_maps)
1331 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1332 AVFormatContext *is, *os;
1333 AVCodecContext *codec, *icodec;
1334 AVOutputStream *ost, **ost_table = NULL;
1335 AVInputStream *ist, **ist_table = NULL;
1336 AVInputFile *file_table;
1337 AVFormatContext *stream_no_data;
1340 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1345 bit_buffer = av_malloc(VIDEO_BUFFER_SIZE);
1349 /* input stream init */
1351 for(i=0;i<nb_input_files;i++) {
1352 is = input_files[i];
1353 file_table[i].ist_index = j;
1354 file_table[i].nb_streams = is->nb_streams;
1355 j += is->nb_streams;
1359 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1363 for(i=0;i<nb_istreams;i++) {
1364 ist = av_mallocz(sizeof(AVInputStream));
1370 for(i=0;i<nb_input_files;i++) {
1371 is = input_files[i];
1372 for(k=0;k<is->nb_streams;k++) {
1373 ist = ist_table[j++];
1374 ist->st = is->streams[k];
1375 ist->file_index = i;
1377 ist->discard = 1; /* the stream is discarded by default
1380 if (ist->st->codec.rate_emu) {
1381 ist->start = av_gettime();
1387 /* output stream init */
1389 for(i=0;i<nb_output_files;i++) {
1390 os = output_files[i];
1391 nb_ostreams += os->nb_streams;
1393 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1394 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1398 /* Sanity check the mapping args -- do the input files & streams exist? */
1399 for(i=0;i<nb_stream_maps;i++) {
1400 int fi = stream_maps[i].file_index;
1401 int si = stream_maps[i].stream_index;
1403 if (fi < 0 || fi > nb_input_files - 1 ||
1404 si < 0 || si > file_table[fi].nb_streams - 1) {
1405 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1410 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1413 for(i=0;i<nb_ostreams;i++) {
1414 ost = av_mallocz(sizeof(AVOutputStream));
1421 for(k=0;k<nb_output_files;k++) {
1422 os = output_files[k];
1423 for(i=0;i<os->nb_streams;i++) {
1425 ost = ost_table[n++];
1426 ost->file_index = k;
1428 ost->st = os->streams[i];
1429 if (nb_stream_maps > 0) {
1430 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1431 stream_maps[n-1].stream_index;
1433 /* Sanity check that the stream types match */
1434 if (ist_table[ost->source_index]->st->codec.codec_type != ost->st->codec.codec_type) {
1435 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1436 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1437 ost->file_index, ost->index);
1442 /* get corresponding input stream index : we select the first one with the right type */
1444 for(j=0;j<nb_istreams;j++) {
1447 ist->st->codec.codec_type == ost->st->codec.codec_type) {
1448 ost->source_index = j;
1454 /* try again and reuse existing stream */
1455 for(j=0;j<nb_istreams;j++) {
1457 if (ist->st->codec.codec_type == ost->st->codec.codec_type) {
1458 ost->source_index = j;
1463 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1464 ost->file_index, ost->index);
1469 ist = ist_table[ost->source_index];
1474 /* for each output stream, we compute the right encoding parameters */
1475 for(i=0;i<nb_ostreams;i++) {
1477 ist = ist_table[ost->source_index];
1479 codec = &ost->st->codec;
1480 icodec = &ist->st->codec;
1482 if (ost->st->stream_copy) {
1483 /* if stream_copy is selected, no need to decode or encode */
1484 codec->codec_id = icodec->codec_id;
1485 codec->codec_type = icodec->codec_type;
1486 codec->codec_tag = icodec->codec_tag;
1487 codec->bit_rate = icodec->bit_rate;
1488 switch(codec->codec_type) {
1489 case CODEC_TYPE_AUDIO:
1490 codec->sample_rate = icodec->sample_rate;
1491 codec->channels = icodec->channels;
1492 codec->frame_size = icodec->frame_size;
1494 case CODEC_TYPE_VIDEO:
1495 codec->frame_rate = icodec->frame_rate;
1496 codec->frame_rate_base = icodec->frame_rate_base;
1497 codec->width = icodec->width;
1498 codec->height = icodec->height;
1504 switch(codec->codec_type) {
1505 case CODEC_TYPE_AUDIO:
1506 if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1509 if (codec->channels == icodec->channels &&
1510 codec->sample_rate == icodec->sample_rate) {
1511 ost->audio_resample = 0;
1513 if (codec->channels != icodec->channels &&
1514 (icodec->codec_id == CODEC_ID_AC3 ||
1515 icodec->codec_id == CODEC_ID_DTS)) {
1516 /* Special case for 5:1 AC3 and DTS input */
1517 /* and mono or stereo output */
1518 /* Request specific number of channels */
1519 icodec->channels = codec->channels;
1520 if (codec->sample_rate == icodec->sample_rate)
1521 ost->audio_resample = 0;
1523 ost->audio_resample = 1;
1526 ost->audio_resample = 1;
1529 if(audio_sync_method>1)
1530 ost->audio_resample = 1;
1532 if(ost->audio_resample){
1533 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1534 codec->sample_rate, icodec->sample_rate);
1536 printf("Can't resample. Aborting.\n");
1540 ist->decoding_needed = 1;
1541 ost->encoding_needed = 1;
1543 case CODEC_TYPE_VIDEO:
1544 if (codec->width == icodec->width &&
1545 codec->height == icodec->height &&
1546 frame_topBand == 0 &&
1547 frame_bottomBand == 0 &&
1548 frame_leftBand == 0 &&
1549 frame_rightBand == 0 &&
1550 frame_padtop == 0 &&
1551 frame_padbottom == 0 &&
1552 frame_padleft == 0 &&
1553 frame_padright == 0)
1555 ost->video_resample = 0;
1556 ost->video_crop = 0;
1558 } else if ((codec->width == icodec->width -
1559 (frame_leftBand + frame_rightBand)) &&
1560 (codec->height == icodec->height -
1561 (frame_topBand + frame_bottomBand)))
1563 ost->video_resample = 0;
1564 ost->video_crop = 1;
1565 ost->topBand = frame_topBand;
1566 ost->leftBand = frame_leftBand;
1567 } else if ((codec->width == icodec->width +
1568 (frame_padleft + frame_padright)) &&
1569 (codec->height == icodec->height +
1570 (frame_padtop + frame_padbottom))) {
1571 ost->video_resample = 0;
1572 ost->video_crop = 0;
1574 ost->padtop = frame_padtop;
1575 ost->padleft = frame_padleft;
1576 ost->padbottom = frame_padbottom;
1577 ost->padright = frame_padright;
1578 avcodec_get_frame_defaults(&ost->pict_tmp);
1579 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1580 codec->width, codec->height ) )
1583 ost->video_resample = 1;
1584 ost->video_crop = 0; // cropping is handled as part of resample
1585 avcodec_get_frame_defaults(&ost->pict_tmp);
1586 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1587 codec->width, codec->height ) )
1590 ost->img_resample_ctx = img_resample_full_init(
1591 ost->st->codec.width, ost->st->codec.height,
1592 ist->st->codec.width, ist->st->codec.height,
1593 frame_topBand, frame_bottomBand,
1594 frame_leftBand, frame_rightBand,
1595 frame_padtop, frame_padbottom,
1596 frame_padleft, frame_padright);
1598 ost->padtop = frame_padtop;
1599 ost->padleft = frame_padleft;
1600 ost->padbottom = frame_padbottom;
1601 ost->padright = frame_padright;
1604 ost->encoding_needed = 1;
1605 ist->decoding_needed = 1;
1611 if (ost->encoding_needed &&
1612 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1613 char logfilename[1024];
1618 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1620 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1621 if (codec->flags & CODEC_FLAG_PASS1) {
1622 f = fopen(logfilename, "w");
1624 perror(logfilename);
1629 /* read the log file */
1630 f = fopen(logfilename, "r");
1632 perror(logfilename);
1635 fseek(f, 0, SEEK_END);
1637 fseek(f, 0, SEEK_SET);
1638 logbuffer = av_malloc(size + 1);
1640 fprintf(stderr, "Could not allocate log buffer\n");
1643 size = fread(logbuffer, 1, size, f);
1645 logbuffer[size] = '\0';
1646 codec->stats_in = logbuffer;
1652 /* dump the file output parameters - cannot be done before in case
1654 for(i=0;i<nb_output_files;i++) {
1655 dump_format(output_files[i], i, output_files[i]->filename, 1);
1658 /* dump the stream mapping */
1660 fprintf(stderr, "Stream mapping:\n");
1661 for(i=0;i<nb_ostreams;i++) {
1663 fprintf(stderr, " Stream #%d.%d -> #%d.%d\n",
1664 ist_table[ost->source_index]->file_index,
1665 ist_table[ost->source_index]->index,
1671 /* open each encoder */
1672 for(i=0;i<nb_ostreams;i++) {
1674 if (ost->encoding_needed) {
1676 codec = avcodec_find_encoder(ost->st->codec.codec_id);
1678 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1679 ost->file_index, ost->index);
1682 if (avcodec_open(&ost->st->codec, codec) < 0) {
1683 fprintf(stderr, "Error while opening codec for stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1684 ost->file_index, ost->index);
1687 extra_size += ost->st->codec.extradata_size;
1691 /* open each decoder */
1692 for(i=0;i<nb_istreams;i++) {
1694 if (ist->decoding_needed) {
1696 codec = avcodec_find_decoder(ist->st->codec.codec_id);
1698 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1699 ist->st->codec.codec_id, ist->file_index, ist->index);
1702 if (avcodec_open(&ist->st->codec, codec) < 0) {
1703 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1704 ist->file_index, ist->index);
1707 //if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO)
1708 // ist->st->codec.flags |= CODEC_FLAG_REPEAT_FIELD;
1713 for(i=0;i<nb_istreams;i++) {
1715 is = input_files[ist->file_index];
1721 /* compute buffer size max (should use a complete heuristic) */
1722 for(i=0;i<nb_input_files;i++) {
1723 file_table[i].buffer_size_max = 2048;
1726 /* set meta data information from input file if required */
1727 for (i=0;i<nb_meta_data_maps;i++) {
1728 AVFormatContext *out_file;
1729 AVFormatContext *in_file;
1731 int out_file_index = meta_data_maps[i].out_file;
1732 int in_file_index = meta_data_maps[i].in_file;
1733 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1734 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1738 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1739 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1744 out_file = output_files[out_file_index];
1745 in_file = input_files[in_file_index];
1747 strcpy(out_file->title, in_file->title);
1748 strcpy(out_file->author, in_file->author);
1749 strcpy(out_file->copyright, in_file->copyright);
1750 strcpy(out_file->comment, in_file->comment);
1751 strcpy(out_file->album, in_file->album);
1752 out_file->year = in_file->year;
1753 out_file->track = in_file->track;
1754 strcpy(out_file->genre, in_file->genre);
1757 /* open files and write file headers */
1758 for(i=0;i<nb_output_files;i++) {
1759 os = output_files[i];
1760 if (av_write_header(os) < 0) {
1761 fprintf(stderr, "Could not write header for output file #%d (incorrect codec paramters ?)\n", i);
1767 #ifndef CONFIG_WIN32
1768 if ( !using_stdin && verbose >= 0) {
1769 fprintf(stderr, "Press [q] to stop encoding\n");
1770 url_set_interrupt_cb(decode_interrupt_cb);
1778 for(; received_sigterm == 0;) {
1779 int file_index, ist_index;
1781 double ipts_min= 1e100;
1782 double opts_min= 1e100;
1785 /* if 'q' pressed, exits */
1789 /* read_key() returns 0 on EOF */
1795 /* select the stream that we must read now by looking at the
1796 smallest output pts */
1798 for(i=0;i<nb_ostreams;i++) {
1801 os = output_files[ost->file_index];
1802 ist = ist_table[ost->source_index];
1803 if(ost->st->codec.codec_type == CODEC_TYPE_VIDEO)
1804 opts = (double)ost->sync_opts * ost->st->codec.frame_rate_base / ost->st->codec.frame_rate;
1806 opts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1807 ipts = (double)ist->pts;
1808 if (!file_table[ist->file_index].eof_reached){
1809 if(ipts < ipts_min) {
1811 if(input_sync ) file_index = ist->file_index;
1813 if(opts < opts_min) {
1815 if(!input_sync) file_index = ist->file_index;
1819 /* if none, if is finished */
1820 if (file_index < 0) {
1824 /* finish if recording time exhausted */
1825 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1828 /* read a frame from it and output it in the fifo */
1829 is = input_files[file_index];
1830 if (av_read_frame(is, &pkt) < 0) {
1831 file_table[file_index].eof_reached = 1;
1836 stream_no_data = is;
1841 av_pkt_dump(stdout, &pkt, do_hex_dump);
1843 /* the following test is needed in case new streams appear
1844 dynamically in stream : we ignore them */
1845 if (pkt.stream_index >= file_table[file_index].nb_streams)
1846 goto discard_packet;
1847 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1848 ist = ist_table[ist_index];
1850 goto discard_packet;
1852 // 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);
1853 if (pkt.dts != AV_NOPTS_VALUE) {
1854 int64_t delta= pkt.dts - ist->next_pts;
1855 if(ABS(delta) > 10LL*AV_TIME_BASE && !copy_ts){
1856 input_files_ts_offset[ist->file_index]-= delta;
1858 fprintf(stderr, "timestamp discontinuity %lld, new offset= %lld\n", delta, input_files_ts_offset[ist->file_index]);
1859 for(i=0; i<file_table[file_index].nb_streams; i++){
1860 int index= file_table[file_index].ist_index + i;
1861 ist_table[index]->next_pts += delta;
1862 ist_table[index]->is_start=1;
1867 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1868 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1871 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1872 ist->file_index, ist->index);
1874 av_free_packet(&pkt);
1879 av_free_packet(&pkt);
1881 /* dump report by using the output first video and audio streams */
1882 print_report(output_files, ost_table, nb_ostreams, 0);
1885 /* at the end of stream, we must flush the decoder buffers */
1886 for(i=0;i<nb_istreams;i++) {
1888 if (ist->decoding_needed) {
1889 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1895 /* write the trailer if needed and close file */
1896 for(i=0;i<nb_output_files;i++) {
1897 os = output_files[i];
1898 av_write_trailer(os);
1901 /* dump report by using the first video and audio streams */
1902 print_report(output_files, ost_table, nb_ostreams, 1);
1904 /* close each encoder */
1905 for(i=0;i<nb_ostreams;i++) {
1907 if (ost->encoding_needed) {
1908 av_freep(&ost->st->codec.stats_in);
1909 avcodec_close(&ost->st->codec);
1913 /* close each decoder */
1914 for(i=0;i<nb_istreams;i++) {
1916 if (ist->decoding_needed) {
1917 avcodec_close(&ist->st->codec);
1925 av_free(file_table);
1928 for(i=0;i<nb_istreams;i++) {
1935 for(i=0;i<nb_ostreams;i++) {
1939 fclose(ost->logfile);
1940 ost->logfile = NULL;
1942 fifo_free(&ost->fifo); /* works even if fifo is not
1943 initialized but set to zero */
1944 av_free(ost->pict_tmp.data[0]);
1945 if (ost->video_resample)
1946 img_resample_close(ost->img_resample_ctx);
1947 if (ost->audio_resample)
1948 audio_resample_close(ost->resample);
1961 int file_read(const char *filename)
1964 unsigned char buffer[1024];
1967 if (url_open(&h, filename, O_RDONLY) < 0) {
1968 printf("could not open '%s'\n", filename);
1972 len = url_read(h, buffer, sizeof(buffer));
1975 for(i=0;i<len;i++) putchar(buffer[i]);
1982 static void opt_image_format(const char *arg)
1986 for(f = first_image_format; f != NULL; f = f->next) {
1987 if (!strcmp(arg, f->name))
1991 fprintf(stderr, "Unknown image format: '%s'\n", arg);
1997 static void opt_format(const char *arg)
1999 /* compatibility stuff for pgmyuv */
2000 if (!strcmp(arg, "pgmyuv")) {
2001 opt_image_format(arg);
2005 file_iformat = av_find_input_format(arg);
2006 file_oformat = guess_format(arg, NULL, NULL);
2007 if (!file_iformat && !file_oformat) {
2008 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2013 static void opt_video_bitrate(const char *arg)
2015 video_bit_rate = atoi(arg) * 1000;
2018 static void opt_video_bitrate_tolerance(const char *arg)
2020 video_bit_rate_tolerance = atoi(arg) * 1000;
2023 static void opt_video_bitrate_max(const char *arg)
2025 video_rc_max_rate = atoi(arg) * 1000;
2028 static void opt_video_bitrate_min(const char *arg)
2030 video_rc_min_rate = atoi(arg) * 1000;
2033 static void opt_video_buffer_size(const char *arg)
2035 video_rc_buffer_size = atoi(arg) * 8*1024;
2038 static void opt_video_rc_eq(char *arg)
2043 static void opt_video_rc_override_string(char *arg)
2045 video_rc_override_string = arg;
2049 static void opt_workaround_bugs(const char *arg)
2051 workaround_bugs = atoi(arg);
2054 static void opt_dct_algo(const char *arg)
2056 dct_algo = atoi(arg);
2059 static void opt_idct_algo(const char *arg)
2061 idct_algo = atoi(arg);
2064 static void opt_me_threshold(const char *arg)
2066 me_threshold = atoi(arg);
2069 static void opt_mb_threshold(const char *arg)
2071 mb_threshold = atoi(arg);
2074 static void opt_error_resilience(const char *arg)
2076 error_resilience = atoi(arg);
2079 static void opt_error_concealment(const char *arg)
2081 error_concealment = atoi(arg);
2084 static void opt_debug(const char *arg)
2089 static void opt_vismv(const char *arg)
2091 debug_mv = atoi(arg);
2094 static void opt_verbose(const char *arg)
2096 verbose = atoi(arg);
2097 av_log_set_level(atoi(arg));
2100 static void opt_frame_rate(const char *arg)
2102 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2103 fprintf(stderr, "Incorrect frame rate\n");
2108 static void opt_frame_crop_top(const char *arg)
2110 frame_topBand = atoi(arg);
2111 if (frame_topBand < 0) {
2112 fprintf(stderr, "Incorrect top crop size\n");
2115 if ((frame_topBand % 2) != 0) {
2116 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2119 if ((frame_topBand) >= frame_height){
2120 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2123 frame_height -= frame_topBand;
2126 static void opt_frame_crop_bottom(const char *arg)
2128 frame_bottomBand = atoi(arg);
2129 if (frame_bottomBand < 0) {
2130 fprintf(stderr, "Incorrect bottom crop size\n");
2133 if ((frame_bottomBand % 2) != 0) {
2134 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2137 if ((frame_bottomBand) >= frame_height){
2138 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2141 frame_height -= frame_bottomBand;
2144 static void opt_frame_crop_left(const char *arg)
2146 frame_leftBand = atoi(arg);
2147 if (frame_leftBand < 0) {
2148 fprintf(stderr, "Incorrect left crop size\n");
2151 if ((frame_leftBand % 2) != 0) {
2152 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2155 if ((frame_leftBand) >= frame_width){
2156 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2159 frame_width -= frame_leftBand;
2162 static void opt_frame_crop_right(const char *arg)
2164 frame_rightBand = atoi(arg);
2165 if (frame_rightBand < 0) {
2166 fprintf(stderr, "Incorrect right crop size\n");
2169 if ((frame_rightBand % 2) != 0) {
2170 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2173 if ((frame_rightBand) >= frame_width){
2174 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2177 frame_width -= frame_rightBand;
2180 static void opt_frame_size(const char *arg)
2182 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2183 fprintf(stderr, "Incorrect frame size\n");
2186 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2187 fprintf(stderr, "Frame size must be a multiple of 2\n");
2193 #define SCALEBITS 10
2194 #define ONE_HALF (1 << (SCALEBITS - 1))
2195 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2197 #define RGB_TO_Y(r, g, b) \
2198 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2199 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2201 #define RGB_TO_U(r1, g1, b1, shift)\
2202 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2203 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2205 #define RGB_TO_V(r1, g1, b1, shift)\
2206 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2207 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2209 static void opt_pad_color(const char *arg) {
2210 /* Input is expected to be six hex digits similar to
2211 how colors are expressed in html tags (but without the #) */
2212 int rgb = strtol(arg, NULL, 16);
2216 g = ((rgb >> 8) & 255);
2219 padcolor[0] = RGB_TO_Y(r,g,b);
2220 padcolor[1] = RGB_TO_U(r,g,b,0);
2221 padcolor[2] = RGB_TO_V(r,g,b,0);
2224 static void opt_frame_pad_top(const char *arg)
2226 frame_padtop = atoi(arg);
2227 if (frame_padtop < 0) {
2228 fprintf(stderr, "Incorrect top pad size\n");
2231 if ((frame_padtop % 2) != 0) {
2232 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2237 static void opt_frame_pad_bottom(const char *arg)
2239 frame_padbottom = atoi(arg);
2240 if (frame_padbottom < 0) {
2241 fprintf(stderr, "Incorrect bottom pad size\n");
2244 if ((frame_padbottom % 2) != 0) {
2245 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2251 static void opt_frame_pad_left(const char *arg)
2253 frame_padleft = atoi(arg);
2254 if (frame_padleft < 0) {
2255 fprintf(stderr, "Incorrect left pad size\n");
2258 if ((frame_padleft % 2) != 0) {
2259 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2265 static void opt_frame_pad_right(const char *arg)
2267 frame_padright = atoi(arg);
2268 if (frame_padright < 0) {
2269 fprintf(stderr, "Incorrect right pad size\n");
2272 if ((frame_padright % 2) != 0) {
2273 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2279 static void opt_frame_pix_fmt(const char *arg)
2281 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2284 static void opt_frame_aspect_ratio(const char *arg)
2290 p = strchr(arg, ':');
2292 x = strtol(arg, (char **)&arg, 10);
2294 y = strtol(arg+1, (char **)&arg, 10);
2296 ar = (double)x / (double)y;
2298 ar = strtod(arg, (char **)&arg);
2301 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2304 frame_aspect_ratio = ar;
2307 static void opt_gop_size(const char *arg)
2309 gop_size = atoi(arg);
2312 static void opt_b_frames(const char *arg)
2314 b_frames = atoi(arg);
2315 if (b_frames > FF_MAX_B_FRAMES) {
2316 fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2318 } else if (b_frames < 1) {
2319 fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2324 static void opt_mb_decision(const char *arg)
2326 mb_decision = atoi(arg);
2329 static void opt_mb_cmp(const char *arg)
2334 static void opt_ildct_cmp(const char *arg)
2336 ildct_cmp = atoi(arg);
2339 static void opt_sub_cmp(const char *arg)
2341 sub_cmp = atoi(arg);
2344 static void opt_cmp(const char *arg)
2349 static void opt_pre_cmp(const char *arg)
2351 pre_cmp = atoi(arg);
2354 static void opt_pre_me(const char *arg)
2359 static void opt_lumi_mask(const char *arg)
2361 lumi_mask = atof(arg);
2364 static void opt_dark_mask(const char *arg)
2366 dark_mask = atof(arg);
2369 static void opt_scplx_mask(const char *arg)
2371 scplx_mask = atof(arg);
2374 static void opt_tcplx_mask(const char *arg)
2376 tcplx_mask = atof(arg);
2379 static void opt_p_mask(const char *arg)
2384 static void opt_qscale(const char *arg)
2386 video_qscale = atof(arg);
2387 if (video_qscale < 0.01 ||
2388 video_qscale > 255) {
2389 fprintf(stderr, "qscale must be >= 0.01 and <= 255\n");
2394 static void opt_lmax(const char *arg)
2396 video_lmax = atof(arg)*FF_QP2LAMBDA;
2399 static void opt_lmin(const char *arg)
2401 video_lmin = atof(arg)*FF_QP2LAMBDA;
2404 static void opt_qmin(const char *arg)
2406 video_qmin = atoi(arg);
2407 if (video_qmin < 0 ||
2409 fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2414 static void opt_qmax(const char *arg)
2416 video_qmax = atoi(arg);
2417 if (video_qmax < 0 ||
2419 fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2424 static void opt_mb_qmin(const char *arg)
2426 video_mb_qmin = atoi(arg);
2427 if (video_mb_qmin < 0 ||
2428 video_mb_qmin > 31) {
2429 fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2434 static void opt_mb_qmax(const char *arg)
2436 video_mb_qmax = atoi(arg);
2437 if (video_mb_qmax < 0 ||
2438 video_mb_qmax > 31) {
2439 fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2444 static void opt_qdiff(const char *arg)
2446 video_qdiff = atoi(arg);
2447 if (video_qdiff < 0 ||
2449 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2454 static void opt_qblur(const char *arg)
2456 video_qblur = atof(arg);
2459 static void opt_qcomp(const char *arg)
2461 video_qcomp = atof(arg);
2464 static void opt_rc_initial_cplx(const char *arg)
2466 video_rc_initial_cplx = atof(arg);
2468 static void opt_b_qfactor(const char *arg)
2470 video_b_qfactor = atof(arg);
2472 static void opt_i_qfactor(const char *arg)
2474 video_i_qfactor = atof(arg);
2476 static void opt_b_qoffset(const char *arg)
2478 video_b_qoffset = atof(arg);
2480 static void opt_i_qoffset(const char *arg)
2482 video_i_qoffset = atof(arg);
2485 static void opt_ibias(const char *arg)
2487 video_intra_quant_bias = atoi(arg);
2489 static void opt_pbias(const char *arg)
2491 video_inter_quant_bias = atoi(arg);
2494 static void opt_packet_size(const char *arg)
2496 packet_size= atoi(arg);
2499 static void opt_error_rate(const char *arg)
2501 error_rate= atoi(arg);
2504 static void opt_strict(const char *arg)
2509 static void opt_top_field_first(const char *arg)
2511 top_field_first= atoi(arg);
2514 static void opt_noise_reduction(const char *arg)
2516 noise_reduction= atoi(arg);
2519 static void opt_qns(const char *arg)
2524 static void opt_sc_threshold(const char *arg)
2526 sc_threshold= atoi(arg);
2529 static void opt_me_range(const char *arg)
2531 me_range = atoi(arg);
2534 static void opt_thread_count(const char *arg)
2536 thread_count= atoi(arg);
2537 #if !defined(HAVE_PTHREADS) && !defined(HAVE_W32THREADS)
2539 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2543 static void opt_audio_bitrate(const char *arg)
2545 audio_bit_rate = atoi(arg) * 1000;
2548 static void opt_audio_rate(const char *arg)
2550 audio_sample_rate = atoi(arg);
2553 static void opt_audio_channels(const char *arg)
2555 audio_channels = atoi(arg);
2558 static void opt_video_device(const char *arg)
2560 video_device = av_strdup(arg);
2563 static void opt_video_channel(const char *arg)
2565 video_channel = strtol(arg, NULL, 0);
2568 static void opt_video_standard(const char *arg)
2570 video_standard = av_strdup(arg);
2573 static void opt_audio_device(const char *arg)
2575 audio_device = av_strdup(arg);
2578 static void opt_dv1394(const char *arg)
2580 video_grab_format = "dv1394";
2581 audio_grab_format = NULL;
2584 static void opt_audio_codec(const char *arg)
2588 if (!strcmp(arg, "copy")) {
2589 audio_stream_copy = 1;
2593 if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_AUDIO)
2598 fprintf(stderr, "Unknown audio codec '%s'\n", arg);
2601 audio_codec_id = p->id;
2606 static void add_frame_hooker(const char *arg)
2611 char *args = av_strdup(arg);
2615 argv[0] = strtok(args, " ");
2616 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2619 i = frame_hook_add(argc, argv);
2622 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2627 const char *motion_str[] = {
2637 static void opt_motion_estimation(const char *arg)
2643 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2646 if (!strcmp(*p, arg))
2650 me_method = (p - motion_str) + 1;
2653 static void opt_video_codec(const char *arg)
2657 if (!strcmp(arg, "copy")) {
2658 video_stream_copy = 1;
2662 if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_VIDEO)
2667 fprintf(stderr, "Unknown video codec '%s'\n", arg);
2670 video_codec_id = p->id;
2675 static void opt_map(const char *arg)
2681 m = &stream_maps[nb_stream_maps++];
2683 m->file_index = strtol(arg, (char **)&p, 0);
2687 m->stream_index = strtol(p, (char **)&p, 0);
2690 static void opt_map_meta_data(const char *arg)
2696 m = &meta_data_maps[nb_meta_data_maps++];
2698 m->out_file = strtol(arg, (char **)&p, 0);
2702 m->in_file = strtol(p, (char **)&p, 0);
2705 static void opt_recording_time(const char *arg)
2707 recording_time = parse_date(arg, 1);
2710 static void opt_start_time(const char *arg)
2712 start_time = parse_date(arg, 1);
2715 static void opt_rec_timestamp(const char *arg)
2717 rec_timestamp = parse_date(arg, 0) / 1000000;
2720 static void opt_input_ts_offset(const char *arg)
2722 input_ts_offset = parse_date(arg, 1);
2725 static void opt_input_file(const char *filename)
2727 AVFormatContext *ic;
2728 AVFormatParameters params, *ap = ¶ms;
2729 int err, i, ret, rfps, rfps_base;
2731 if (!strcmp(filename, "-"))
2734 using_stdin |= !strcmp(filename, "pipe:" ) ||
2735 !strcmp( filename, "/dev/stdin" );
2737 /* get default parameters from command line */
2738 memset(ap, 0, sizeof(*ap));
2739 ap->sample_rate = audio_sample_rate;
2740 ap->channels = audio_channels;
2741 ap->frame_rate = frame_rate;
2742 ap->frame_rate_base = frame_rate_base;
2743 ap->width = frame_width + frame_padleft + frame_padright;
2744 ap->height = frame_height + frame_padtop + frame_padbottom;
2745 ap->image_format = image_format;
2746 ap->pix_fmt = frame_pix_fmt;
2748 /* open the input file with generic libav function */
2749 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2751 print_error(filename, err);
2755 /* If not enough info to get the stream parameters, we decode the
2756 first frames to get it. (used in mpeg case for example) */
2757 ret = av_find_stream_info(ic);
2758 if (ret < 0 && verbose >= 0) {
2759 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2763 /* if seeking requested, we execute it */
2764 if (start_time != 0) {
2767 timestamp = start_time;
2768 /* add the stream start time */
2769 if (ic->start_time != AV_NOPTS_VALUE)
2770 timestamp += ic->start_time;
2771 ret = av_seek_frame(ic, -1, timestamp);
2773 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2774 filename, (double)timestamp / AV_TIME_BASE);
2776 /* reset seek info */
2780 /* update the current parameters so that they match the one of the input stream */
2781 for(i=0;i<ic->nb_streams;i++) {
2782 AVCodecContext *enc = &ic->streams[i]->codec;
2783 #if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
2785 avcodec_thread_init(enc, thread_count);
2787 enc->thread_count= thread_count;
2788 switch(enc->codec_type) {
2789 case CODEC_TYPE_AUDIO:
2790 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2791 audio_channels = enc->channels;
2792 audio_sample_rate = enc->sample_rate;
2794 case CODEC_TYPE_VIDEO:
2795 frame_height = enc->height;
2796 frame_width = enc->width;
2797 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2798 frame_pix_fmt = enc->pix_fmt;
2799 rfps = ic->streams[i]->r_frame_rate;
2800 rfps_base = ic->streams[i]->r_frame_rate_base;
2801 enc->workaround_bugs = workaround_bugs;
2802 enc->error_resilience = error_resilience;
2803 enc->error_concealment = error_concealment;
2804 enc->idct_algo = idct_algo;
2806 enc->debug_mv = debug_mv;
2808 enc->flags|= CODEC_FLAG_BITEXACT;
2810 enc->debug |= FF_DEBUG_MV;
2812 assert(enc->frame_rate_base == rfps_base); // should be true for now
2813 if (enc->frame_rate != rfps) {
2816 fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f->%2.2f\n",
2817 i, (float)enc->frame_rate / enc->frame_rate_base,
2819 (float)rfps / rfps_base);
2821 /* update the current frame rate to match the stream frame rate */
2823 frame_rate_base = rfps_base;
2825 enc->rate_emu = rate_emu;
2827 case CODEC_TYPE_DATA:
2834 input_files[nb_input_files] = ic;
2835 input_files_ts_offset[nb_input_files] = input_ts_offset;
2836 /* dump the file content */
2838 dump_format(ic, nb_input_files, filename, 0);
2841 file_iformat = NULL;
2842 file_oformat = NULL;
2843 image_format = NULL;
2848 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2850 int has_video, has_audio, i, j;
2851 AVFormatContext *ic;
2855 for(j=0;j<nb_input_files;j++) {
2856 ic = input_files[j];
2857 for(i=0;i<ic->nb_streams;i++) {
2858 AVCodecContext *enc = &ic->streams[i]->codec;
2859 switch(enc->codec_type) {
2860 case CODEC_TYPE_AUDIO:
2863 case CODEC_TYPE_VIDEO:
2866 case CODEC_TYPE_DATA:
2873 *has_video_ptr = has_video;
2874 *has_audio_ptr = has_audio;
2877 static void opt_output_file(const char *filename)
2880 AVFormatContext *oc;
2881 int use_video, use_audio, nb_streams, input_has_video, input_has_audio;
2883 AVFormatParameters params, *ap = ¶ms;
2885 if (!strcmp(filename, "-"))
2888 oc = av_alloc_format_context();
2890 if (!file_oformat) {
2891 file_oformat = guess_format(NULL, filename, NULL);
2892 if (!file_oformat) {
2893 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
2899 oc->oformat = file_oformat;
2901 if (!strcmp(file_oformat->name, "ffm") &&
2902 strstart(filename, "http:", NULL)) {
2903 /* special case for files sent to ffserver: we get the stream
2904 parameters from ffserver */
2905 if (read_ffserver_streams(oc, filename) < 0) {
2906 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
2910 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy;
2911 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy;
2913 /* disable if no corresponding type found and at least one
2915 if (nb_input_files > 0) {
2916 check_audio_video_inputs(&input_has_video, &input_has_audio);
2917 if (!input_has_video)
2919 if (!input_has_audio)
2923 /* manual disable */
2924 if (audio_disable) {
2927 if (video_disable) {
2933 AVCodecContext *video_enc;
2935 st = av_new_stream(oc, nb_streams++);
2937 fprintf(stderr, "Could not alloc stream\n");
2940 #if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
2942 avcodec_thread_init(&st->codec, thread_count);
2945 video_enc = &st->codec;
2947 if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
2948 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2949 if (video_stream_copy) {
2950 st->stream_copy = 1;
2951 video_enc->codec_type = CODEC_TYPE_VIDEO;
2957 codec_id = file_oformat->video_codec;
2958 if (video_codec_id != CODEC_ID_NONE)
2959 codec_id = video_codec_id;
2961 video_enc->codec_id = codec_id;
2962 codec = avcodec_find_encoder(codec_id);
2964 video_enc->bit_rate = video_bit_rate;
2965 video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
2966 video_enc->frame_rate = frame_rate;
2967 video_enc->frame_rate_base = frame_rate_base;
2968 if(codec && codec->supported_framerates){
2969 const AVRational *p= codec->supported_framerates;
2970 AVRational req= (AVRational){frame_rate, frame_rate_base};
2971 const AVRational *best=NULL;
2972 AVRational best_error= (AVRational){INT_MAX, 1};
2973 for(; p->den!=0; p++){
2974 AVRational error= av_sub_q(req, *p);
2975 if(error.num <0) error.num *= -1;
2976 if(av_cmp_q(error, best_error) < 0){
2981 video_enc->frame_rate = best->num;
2982 video_enc->frame_rate_base= best->den;
2985 video_enc->width = frame_width + frame_padright + frame_padleft;
2986 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2987 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
2988 video_enc->pix_fmt = frame_pix_fmt;
2990 if(codec && codec->pix_fmts){
2991 const enum PixelFormat *p= codec->pix_fmts;
2993 if(*p == video_enc->pix_fmt)
2997 video_enc->pix_fmt = codec->pix_fmts[0];
3001 video_enc->gop_size = gop_size;
3003 video_enc->gop_size = 0;
3004 if (video_qscale || same_quality) {
3005 video_enc->flags |= CODEC_FLAG_QSCALE;
3006 st->quality = FF_QP2LAMBDA * video_qscale;
3010 video_enc->intra_matrix = intra_matrix;
3012 video_enc->inter_matrix = inter_matrix;
3015 video_enc->flags |= CODEC_FLAG_BITEXACT;
3017 video_enc->mb_decision = mb_decision;
3018 video_enc->mb_cmp = mb_cmp;
3019 video_enc->ildct_cmp = ildct_cmp;
3020 video_enc->me_sub_cmp = sub_cmp;
3021 video_enc->me_cmp = cmp;
3022 video_enc->me_pre_cmp = pre_cmp;
3023 video_enc->pre_me = pre_me;
3024 video_enc->lumi_masking = lumi_mask;
3025 video_enc->dark_masking = dark_mask;
3026 video_enc->spatial_cplx_masking = scplx_mask;
3027 video_enc->temporal_cplx_masking = tcplx_mask;
3028 video_enc->p_masking = p_mask;
3029 video_enc->quantizer_noise_shaping= qns;
3032 video_enc->flags |= CODEC_FLAG_H263P_UMV;
3035 video_enc->flags |= CODEC_FLAG_H263P_SLICE_STRUCT;
3038 video_enc->flags |= CODEC_FLAG_H263P_AIC;
3041 video_enc->flags |= CODEC_FLAG_H263P_AIV;
3044 video_enc->flags |= CODEC_FLAG_4MV;
3047 video_enc->flags |= CODEC_FLAG_OBMC;
3050 video_enc->flags |= CODEC_FLAG_LOOP_FILTER;
3054 video_enc->flags |= CODEC_FLAG_PART;
3057 video_enc->flags |= CODEC_FLAG_ALT_SCAN;
3060 video_enc->flags |= CODEC_FLAG_TRELLIS_QUANT;
3062 if (use_scan_offset) {
3063 video_enc->flags |= CODEC_FLAG_SVCD_SCAN_OFFSET;
3066 video_enc->flags |= CODEC_FLAG_CLOSED_GOP;
3069 video_enc->flags |= CODEC_FLAG_QPEL;
3072 video_enc->flags |= CODEC_FLAG_QP_RD;
3075 video_enc->flags |= CODEC_FLAG_CBP_RD;
3078 video_enc->max_b_frames = b_frames;
3079 video_enc->b_frame_strategy = 0;
3080 video_enc->b_quant_factor = 2.0;
3082 if (do_interlace_dct) {
3083 video_enc->flags |= CODEC_FLAG_INTERLACED_DCT;
3085 if (do_interlace_me) {
3086 video_enc->flags |= CODEC_FLAG_INTERLACED_ME;
3088 video_enc->qmin = video_qmin;
3089 video_enc->qmax = video_qmax;
3090 video_enc->lmin = video_lmin;
3091 video_enc->lmax = video_lmax;
3092 video_enc->mb_qmin = video_mb_qmin;
3093 video_enc->mb_qmax = video_mb_qmax;
3094 video_enc->max_qdiff = video_qdiff;
3095 video_enc->qblur = video_qblur;
3096 video_enc->qcompress = video_qcomp;
3097 video_enc->rc_eq = video_rc_eq;
3098 video_enc->debug = debug;
3099 video_enc->debug_mv = debug_mv;
3100 video_enc->thread_count = thread_count;
3101 p= video_rc_override_string;
3104 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3106 fprintf(stderr, "error parsing rc_override\n");
3109 video_enc->rc_override=
3110 av_realloc(video_enc->rc_override,
3111 sizeof(RcOverride)*(i+1));
3112 video_enc->rc_override[i].start_frame= start;
3113 video_enc->rc_override[i].end_frame = end;
3115 video_enc->rc_override[i].qscale= q;
3116 video_enc->rc_override[i].quality_factor= 1.0;
3119 video_enc->rc_override[i].qscale= 0;
3120 video_enc->rc_override[i].quality_factor= -q/100.0;
3125 video_enc->rc_override_count=i;
3127 video_enc->rc_max_rate = video_rc_max_rate;
3128 video_enc->rc_min_rate = video_rc_min_rate;
3129 video_enc->rc_buffer_size = video_rc_buffer_size;
3130 video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
3131 video_enc->rc_initial_cplx= video_rc_initial_cplx;
3132 video_enc->i_quant_factor = video_i_qfactor;
3133 video_enc->b_quant_factor = video_b_qfactor;
3134 video_enc->i_quant_offset = video_i_qoffset;
3135 video_enc->b_quant_offset = video_b_qoffset;
3136 video_enc->intra_quant_bias = video_intra_quant_bias;
3137 video_enc->inter_quant_bias = video_inter_quant_bias;
3138 video_enc->dct_algo = dct_algo;
3139 video_enc->idct_algo = idct_algo;
3140 video_enc->me_threshold= me_threshold;
3141 video_enc->mb_threshold= mb_threshold;
3142 video_enc->intra_dc_precision= intra_dc_precision - 8;
3143 video_enc->strict_std_compliance = strict;
3144 video_enc->error_rate = error_rate;
3145 video_enc->noise_reduction= noise_reduction;
3146 video_enc->scenechange_threshold= sc_threshold;
3147 video_enc->me_range = me_range;
3148 video_enc->coder_type= coder;
3149 video_enc->context_model= context;
3150 video_enc->prediction_method= predictor;
3153 video_enc->rtp_mode= 1;
3154 video_enc->rtp_payload_size= packet_size;
3158 video_enc->flags|= CODEC_FLAG_PSNR;
3160 video_enc->me_method = me_method;
3165 video_enc->flags |= CODEC_FLAG_PASS1;
3167 video_enc->flags |= CODEC_FLAG_PASS2;
3174 AVCodecContext *audio_enc;
3176 st = av_new_stream(oc, nb_streams++);
3178 fprintf(stderr, "Could not alloc stream\n");
3181 #if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
3183 avcodec_thread_init(&st->codec, thread_count);
3186 audio_enc = &st->codec;
3187 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3189 if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
3190 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3191 if (audio_stream_copy) {
3192 st->stream_copy = 1;
3193 audio_enc->channels = audio_channels;
3195 codec_id = file_oformat->audio_codec;
3196 if (audio_codec_id != CODEC_ID_NONE)
3197 codec_id = audio_codec_id;
3198 audio_enc->codec_id = codec_id;
3200 audio_enc->bit_rate = audio_bit_rate;
3201 audio_enc->strict_std_compliance = strict;
3202 audio_enc->thread_count = thread_count;
3203 /* For audio codecs other than AC3 or DTS we limit */
3204 /* the number of coded channels to stereo */
3205 if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3206 && codec_id != CODEC_ID_DTS) {
3207 audio_enc->channels = 2;
3209 audio_enc->channels = audio_channels;
3211 audio_enc->sample_rate = audio_sample_rate;
3214 oc->nb_streams = nb_streams;
3217 fprintf(stderr, "No audio or video streams available\n");
3221 oc->timestamp = rec_timestamp;
3224 pstrcpy(oc->title, sizeof(oc->title), str_title);
3226 pstrcpy(oc->author, sizeof(oc->author), str_author);
3228 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3230 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3233 output_files[nb_output_files++] = oc;
3235 strcpy(oc->filename, filename);
3237 /* check filename in case of an image number is expected */
3238 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3239 if (filename_number_test(oc->filename) < 0) {
3240 print_error(oc->filename, AVERROR_NUMEXPECTED);
3245 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3246 /* test if it already exists to avoid loosing precious files */
3247 if (!file_overwrite &&
3248 (strchr(filename, ':') == NULL ||
3249 strstart(filename, "file:", NULL))) {
3250 if (url_exist(filename)) {
3253 if ( !using_stdin ) {
3254 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3257 if (toupper(c) != 'Y') {
3258 fprintf(stderr, "Not overwriting - exiting\n");
3263 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3270 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3271 fprintf(stderr, "Could not open '%s'\n", filename);
3276 memset(ap, 0, sizeof(*ap));
3277 ap->image_format = image_format;
3278 if (av_set_parameters(oc, ap) < 0) {
3279 fprintf(stderr, "%s: Invalid encoding parameters\n",
3284 /* reset some options */
3285 file_oformat = NULL;
3286 file_iformat = NULL;
3287 image_format = NULL;
3290 audio_codec_id = CODEC_ID_NONE;
3291 video_codec_id = CODEC_ID_NONE;
3292 audio_stream_copy = 0;
3293 video_stream_copy = 0;
3296 /* prepare dummy protocols for grab */
3297 static void prepare_grab(void)
3299 int has_video, has_audio, i, j;
3300 AVFormatContext *oc;
3301 AVFormatContext *ic;
3302 AVFormatParameters vp1, *vp = &vp1;
3303 AVFormatParameters ap1, *ap = &ap1;
3305 /* see if audio/video inputs are needed */
3308 memset(ap, 0, sizeof(*ap));
3309 memset(vp, 0, sizeof(*vp));
3310 for(j=0;j<nb_output_files;j++) {
3311 oc = output_files[j];
3312 for(i=0;i<oc->nb_streams;i++) {
3313 AVCodecContext *enc = &oc->streams[i]->codec;
3314 switch(enc->codec_type) {
3315 case CODEC_TYPE_AUDIO:
3316 if (enc->sample_rate > ap->sample_rate)
3317 ap->sample_rate = enc->sample_rate;
3318 if (enc->channels > ap->channels)
3319 ap->channels = enc->channels;
3322 case CODEC_TYPE_VIDEO:
3323 if (enc->width > vp->width)
3324 vp->width = enc->width;
3325 if (enc->height > vp->height)
3326 vp->height = enc->height;
3328 assert(enc->frame_rate_base == DEFAULT_FRAME_RATE_BASE);
3329 if (enc->frame_rate > vp->frame_rate){
3330 vp->frame_rate = enc->frame_rate;
3331 vp->frame_rate_base = enc->frame_rate_base;
3341 if (has_video == 0 && has_audio == 0) {
3342 fprintf(stderr, "Output file must have at least one audio or video stream\n");
3347 AVInputFormat *fmt1;
3348 fmt1 = av_find_input_format(video_grab_format);
3349 vp->device = video_device;
3350 vp->channel = video_channel;
3351 vp->standard = video_standard;
3352 if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3353 fprintf(stderr, "Could not find video grab device\n");
3356 /* If not enough info to get the stream parameters, we decode the
3357 first frames to get it. */
3358 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3359 fprintf(stderr, "Could not find video grab parameters\n");
3362 /* by now video grab has one stream */
3363 ic->streams[0]->r_frame_rate = vp->frame_rate;
3364 ic->streams[0]->r_frame_rate_base = vp->frame_rate_base;
3365 input_files[nb_input_files] = ic;
3368 dump_format(ic, nb_input_files, "", 0);
3372 if (has_audio && audio_grab_format) {
3373 AVInputFormat *fmt1;
3374 fmt1 = av_find_input_format(audio_grab_format);
3375 ap->device = audio_device;
3376 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3377 fprintf(stderr, "Could not find audio grab device\n");
3380 input_files[nb_input_files] = ic;
3383 dump_format(ic, nb_input_files, "", 0);
3389 /* same option as mencoder */
3390 static void opt_pass(const char *pass_str)
3393 pass = atoi(pass_str);
3394 if (pass != 1 && pass != 2) {
3395 fprintf(stderr, "pass number can be only 1 or 2\n");
3401 #if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
3402 static int64_t getutime(void)
3404 return av_gettime();
3407 static int64_t getutime(void)
3409 struct rusage rusage;
3411 getrusage(RUSAGE_SELF, &rusage);
3412 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3416 extern int ffm_nopts;
3418 static void opt_bitexact(void)
3421 /* disable generate of real time pts in ffm (need to be supressed anyway) */
3425 static void show_formats(void)
3427 AVInputFormat *ifmt;
3428 AVOutputFormat *ofmt;
3429 AVImageFormat *image_fmt;
3432 const char **pp, *last_name;
3434 printf("File formats:\n");
3439 const char *name=NULL;
3441 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3442 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3443 strcmp(ofmt->name, last_name)>0){
3448 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3449 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3450 strcmp(ifmt->name, last_name)>0){
3454 if(name && strcmp(ifmt->name, name)==0)
3469 printf("Image formats:\n");
3470 for(image_fmt = first_image_format; image_fmt != NULL;
3471 image_fmt = image_fmt->next) {
3474 image_fmt->img_read ? "D":" ",
3475 image_fmt->img_write ? "E":" ",
3480 printf("Codecs:\n");
3488 for(p = first_avcodec; p != NULL; p = p->next) {
3489 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3490 strcmp(p->name, last_name)>0){
3492 decode= encode= cap=0;
3494 if(p2 && strcmp(p->name, p2->name)==0){
3495 if(p->decode) decode=1;
3496 if(p->encode) encode=1;
3497 cap |= p->capabilities;
3502 last_name= p2->name;
3506 decode ? "D": (/*p2->decoder ? "d":*/" "),
3508 p2->type == CODEC_TYPE_AUDIO ? "A":"V",
3509 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3510 cap & CODEC_CAP_DR1 ? "D":" ",
3511 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3513 /* if(p2->decoder && decode==0)
3514 printf(" use %s for decoding", p2->decoder->name);*/
3519 printf("Supported file protocols:\n");
3520 for(up = first_protocol; up != NULL; up = up->next)
3521 printf(" %s:", up->name);
3524 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3525 printf("Motion estimation methods:\n");
3529 if ((pp - motion_str + 1) == ME_ZERO)
3530 printf("(fastest)");
3531 else if ((pp - motion_str + 1) == ME_FULL)
3532 printf("(slowest)");
3533 else if ((pp - motion_str + 1) == ME_EPZS)
3534 printf("(default)");
3539 "Note, the names of encoders and decoders dont always match, so there are\n"
3540 "several cases where the above table shows encoder only or decoder only entries\n"
3541 "even though both encoding and decoding are supported for example, the h263\n"
3542 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3547 void parse_matrix_coeffs(uint16_t *dest, const char *str)
3550 const char *p = str;
3557 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3564 void opt_inter_matrix(const char *arg)
3566 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3567 parse_matrix_coeffs(inter_matrix, arg);
3570 void opt_intra_matrix(const char *arg)
3572 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3573 parse_matrix_coeffs(intra_matrix, arg);
3576 static void opt_target(const char *arg)
3580 if(!strncmp(arg, "pal-", 4)) {
3583 } else if(!strncmp(arg, "ntsc-", 5)) {
3588 /* Calculate FR via float to avoid int overflow */
3589 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3592 } else if((fr == 29970) || (fr == 23976)) {
3595 /* Try to determine PAL/NTSC by peeking in the input files */
3596 if(nb_input_files) {
3598 for(j = 0; j < nb_input_files; j++) {
3599 for(i = 0; i < input_files[j]->nb_streams; i++) {
3600 AVCodecContext *c = &input_files[j]->streams[i]->codec;
3601 if(c->codec_type != CODEC_TYPE_VIDEO)
3603 fr = c->frame_rate * 1000 / c->frame_rate_base;
3607 } else if((fr == 29970) || (fr == 23976)) {
3617 if(verbose && norm >= 0)
3618 printf("Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3622 fprintf(stderr, "Could not determine norm (PAL/NTSC) for target.\n");
3623 fprintf(stderr, "Please prefix target with \"pal-\" or \"ntsc-\",\n");
3624 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3628 if(!strcmp(arg, "vcd")) {
3630 opt_video_codec("mpeg1video");
3631 opt_audio_codec("mp2");
3634 opt_frame_size(norm ? "352x240" : "352x288");
3636 video_bit_rate = 1150000;
3637 video_rc_max_rate = 1150000;
3638 video_rc_min_rate = 1150000;
3639 video_rc_buffer_size = 40*1024*8;
3641 audio_bit_rate = 224000;
3642 audio_sample_rate = 44100;
3644 } else if(!strcmp(arg, "svcd")) {
3646 opt_video_codec("mpeg2video");
3647 opt_audio_codec("mp2");
3650 opt_frame_size(norm ? "480x480" : "480x576");
3651 opt_gop_size(norm ? "18" : "15");
3653 video_bit_rate = 2040000;
3654 video_rc_max_rate = 2516000;
3655 video_rc_min_rate = 0; //1145000;
3656 video_rc_buffer_size = 224*1024*8;
3657 use_scan_offset = 1;
3659 audio_bit_rate = 224000;
3660 audio_sample_rate = 44100;
3662 } else if(!strcmp(arg, "dvd")) {
3664 opt_video_codec("mpeg2video");
3665 opt_audio_codec("ac3");
3668 opt_frame_size(norm ? "720x480" : "720x576");
3669 opt_gop_size(norm ? "18" : "15");
3671 video_bit_rate = 6000000;
3672 video_rc_max_rate = 9000000;
3673 video_rc_min_rate = 0; //1500000;
3674 video_rc_buffer_size = 224*1024*8;
3676 audio_bit_rate = 448000;
3677 audio_sample_rate = 48000;
3680 fprintf(stderr, "Unknown target: %s\n", arg);
3685 static void show_version(void)
3687 printf("ffmpeg " FFMPEG_VERSION "\n"
3690 avcodec_build(), LIBAVFORMAT_BUILD);
3694 const OptionDef options[] = {
3696 { "L", 0, {(void*)show_license}, "show license" },
3697 { "h", 0, {(void*)show_help}, "show help" },
3698 { "version", 0, {(void*)show_version}, "show version" },
3699 { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3700 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3701 { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3702 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3703 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3704 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream" },
3705 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3706 { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3707 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3708 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3709 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3710 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3711 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3712 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3713 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3714 { "debug", HAS_ARG | OPT_EXPERT, {(void*)opt_debug}, "print specific debug info", "" },
3715 { "vismv", HAS_ARG | OPT_EXPERT, {(void*)opt_vismv}, "visualize motion vectors", "" },
3716 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3717 "add timings for benchmarking" },
3718 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3719 "dump each input packet" },
3720 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3721 "when dumping packets, also dump the payload" },
3722 { "bitexact", OPT_EXPERT, {(void*)opt_bitexact}, "only use bit exact algorithms (for codec testing)" },
3723 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3724 { "loop", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3725 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3726 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\" or \"dvd\")", "type" },
3727 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3728 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3729 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3730 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3733 { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
3734 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3735 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3736 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3737 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3738 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3739 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3740 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3741 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3742 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3743 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3744 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3745 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3746 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3747 { "g", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
3748 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3749 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3750 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
3751 { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
3752 { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
3753 { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
3754 { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
3755 { "mbqmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_qmin}, "min macroblock quantiser scale (VBR)", "q" },
3756 { "mbqmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_qmax}, "max macroblock quantiser scale (VBR)", "q" },
3757 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
3758 { "qblur", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
3759 { "qcomp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
3760 { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
3761 { "b_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
3762 { "i_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
3763 { "b_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
3764 { "i_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
3765 { "ibias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ibias}, "intra quant bias", "bias" },
3766 { "pbias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pbias}, "inter quant bias", "bias" },
3767 // { "b_strategy", HAS_ARG | OPT_EXPERT, {(void*)opt_b_strategy}, "dynamic b frame selection strategy", "strategy" },
3768 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3769 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3770 { "bt", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
3771 { "maxrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
3772 { "minrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
3773 { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffere size (in kByte)", "size" },
3774 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3775 { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3777 { "dct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dct_algo}, "set dct algo", "algo" },
3778 { "idct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_idct_algo}, "set idct algo", "algo" },
3779 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
3780 { "mb_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_threshold}, "macroblock threshold", "" },
3781 { "er", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_resilience}, "set error resilience", "n" },
3782 { "ec", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_concealment}, "set error concealment", "bit_mask" },
3783 { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
3784 { "hq", OPT_BOOL, {(void*)&mb_decision}, "activate high quality settings" },
3785 { "mbd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_decision}, "macroblock decision", "mode" },
3786 { "mbcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_cmp}, "macroblock compare function", "cmp function" },
3787 { "ildctcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ildct_cmp}, "ildct compare function", "cmp function" },
3788 { "subcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sub_cmp}, "subpel compare function", "cmp function" },
3789 { "cmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_cmp}, "fullpel compare function", "cmp function" },
3790 { "precmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_cmp}, "pre motion estimation compare function", "cmp function" },
3791 { "preme", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_me}, "pre motion estimation", "" },
3792 { "lumi_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lumi_mask}, "luminance masking", "" },
3793 { "dark_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dark_mask}, "darkness masking", "" },
3794 { "scplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_scplx_mask}, "spatial complexity masking", "" },
3795 { "tcplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_tcplx_mask}, "teporal complexity masking", "" },
3796 { "p_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_p_mask}, "inter masking", "" },
3797 { "4mv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_4mv}, "use four motion vector by macroblock (MPEG4)" },
3798 { "obmc", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_obmc}, "use overlapped block motion compensation (h263+)" },
3799 { "lf", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_loop}, "use loop filter (h263+)" },
3800 { "part", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_part}, "use data partitioning (MPEG4)" },
3801 { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
3802 { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
3803 { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
3804 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3805 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3806 "use same video quality as source (implies VBR)" },
3807 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3808 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3809 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3810 "deinterlace pictures" },
3811 { "ildct", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_dct},
3812 "force interlaced dct support in encoder (MPEG2/MPEG4)" },
3813 { "ilme", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_me},
3814 "force interlaced me support in encoder (MPEG2/MPEG4)" },
3815 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3816 { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
3817 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3818 { "aic", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aic}, "enable Advanced intra coding (h263+)" },
3819 { "aiv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aiv}, "enable Alternative inter vlc (h263+)" },
3820 { "umv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_umv}, "enable Unlimited Motion Vector (h263+)" },
3821 { "ssm", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_ss}, "enable Slice Structured mode (h263+)" },
3822 { "alt", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_alt_scan}, "enable alternate scantable (MPEG2/MPEG4)" },
3823 { "qprd", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qprd}, "" },
3824 { "cbp", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_cbprd}, "" },
3825 { "trell", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_trell}, "enable trellis quantization" },
3826 { "cgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&closed_gop}, "closed gop" },
3827 { "scan_offset", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_scan_offset}, "enable SVCD Scan Offset placeholder" },
3828 { "qpel", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qpel}, "enable 1/4-pel" },
3829 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3830 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3831 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3832 { "nr", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_noise_reduction}, "noise reduction", "" },
3833 { "qns", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qns}, "quantization noise shaping", "" },
3834 { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
3835 { "me_range", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_range}, "limit motion vectors range (1023 for DivX player)", "range" },
3836 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3837 { "coder", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&coder}, "coder type", "" },
3838 { "context", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&context}, "context model", "" },
3839 { "pred", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&predictor}, "prediction method", "" },
3842 { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
3843 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3844 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3845 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3846 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3849 { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
3850 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3851 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3852 { "dv1394", OPT_EXPERT | OPT_GRAB, {(void*)opt_dv1394}, "set DV1394 grab", "" },
3853 { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
3857 static void show_banner(void)
3859 printf("ffmpeg version " FFMPEG_VERSION ", build %d, Copyright (c) 2000-2004 Fabrice Bellard\n",
3861 printf(" built on " __DATE__ " " __TIME__);
3863 printf(", gcc: %s\n", __VERSION__);
3865 printf(", using a non-gcc compiler\n");
3869 static void show_license(void)
3874 "This program is free software; you can redistribute it and/or modify\n"
3875 "it under the terms of the GNU General Public License as published by\n"
3876 "the Free Software Foundation; either version 2 of the License, or\n"
3877 "(at your option) any later version.\n"
3879 "This program is distributed in the hope that it will be useful,\n"
3880 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3881 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
3882 "GNU General Public License for more details.\n"
3884 "You should have received a copy of the GNU General Public License\n"
3885 "along with this program; if not, write to the Free Software\n"
3886 "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n"
3890 "This library is free software; you can redistribute it and/or\n"
3891 "modify it under the terms of the GNU Lesser General Public\n"
3892 "License as published by the Free Software Foundation; either\n"
3893 "version 2 of the License, or (at your option) any later version.\n"
3895 "This library is distributed in the hope that it will be useful,\n"
3896 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3897 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
3898 "Lesser General Public License for more details.\n"
3900 "You should have received a copy of the GNU Lesser General Public\n"
3901 "License along with this library; if not, write to the Free Software\n"
3902 "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n"
3908 static void show_help(void)
3911 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3912 "Hyper fast Audio and Video encoder\n");
3914 show_help_options(options, "Main options:\n",
3915 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3916 show_help_options(options, "\nVideo options:\n",
3917 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3919 show_help_options(options, "\nAdvanced Video options:\n",
3920 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3921 OPT_VIDEO | OPT_EXPERT);
3922 show_help_options(options, "\nAudio options:\n",
3923 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3925 show_help_options(options, "\nAdvanced Audio options:\n",
3926 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3927 OPT_AUDIO | OPT_EXPERT);
3928 show_help_options(options, "\nAudio/Video grab options:\n",
3931 show_help_options(options, "\nAdvanced options:\n",
3932 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3937 void parse_arg_file(const char *filename)
3939 opt_output_file(filename);
3942 int main(int argc, char **argv)
3955 parse_options(argc, argv, options);
3957 /* file converter / grab */
3958 if (nb_output_files <= 0) {
3959 fprintf(stderr, "Must supply at least one output file\n");
3963 if (nb_input_files == 0) {
3969 av_encode(output_files, nb_output_files, input_files, nb_input_files,
3970 stream_maps, nb_stream_maps);
3971 ti = getutime() - ti;
3973 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3977 for(i=0;i<nb_output_files;i++) {
3978 /* maybe av_close_output_file ??? */
3979 AVFormatContext *s = output_files[i];
3981 if (!(s->oformat->flags & AVFMT_NOFILE))
3983 for(j=0;j<s->nb_streams;j++)
3984 av_free(s->streams[j]);
3987 for(i=0;i<nb_input_files;i++)
3988 av_close_input_file(input_files[i]);
3993 av_free(intra_matrix);
3995 av_free(inter_matrix);
3997 #ifdef POWERPC_PERFORMANCE_REPORT
3998 extern void powerpc_display_perf_report(void);
3999 powerpc_display_perf_report();
4000 #endif /* POWERPC_PERFORMANCE_REPORT */
4002 #ifndef CONFIG_WIN32
4003 if (received_sigterm) {
4005 "Received signal %d: terminating.\n",
4006 (int) received_sigterm);
4010 exit(0); /* not all OS-es handle main() return value */