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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 #define HAVE_AV_CONFIG_H
23 #include "framehook.h"
30 #include <sys/ioctl.h>
33 #include <sys/resource.h>
37 #include <sys/types.h>
38 #include <sys/select.h>
41 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
50 #if !defined(INFINITY) && defined(HUGE_VAL)
51 #define INFINITY HUGE_VAL
54 /* select an input stream for an output stream */
55 typedef struct AVStreamMap {
59 int sync_stream_index;
62 /** select an input file for an output file */
63 typedef struct AVMetaDataMap {
68 extern const OptionDef options[];
70 static void show_help(void);
71 static void show_license(void);
72 static int opt_default(const char *opt, const char *arg);
76 static AVFormatContext *input_files[MAX_FILES];
77 static int64_t input_files_ts_offset[MAX_FILES];
78 static int nb_input_files = 0;
80 static AVFormatContext *output_files[MAX_FILES];
81 static int nb_output_files = 0;
83 static AVStreamMap stream_maps[MAX_FILES];
84 static int nb_stream_maps;
86 static AVMetaDataMap meta_data_maps[MAX_FILES];
87 static int nb_meta_data_maps;
89 static AVInputFormat *file_iformat;
90 static AVOutputFormat *file_oformat;
91 static AVImageFormat *image_format;
92 static int frame_width = 0;
93 static int frame_height = 0;
94 static float frame_aspect_ratio = 0;
95 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
96 static int frame_padtop = 0;
97 static int frame_padbottom = 0;
98 static int frame_padleft = 0;
99 static int frame_padright = 0;
100 static int padcolor[3] = {16,128,128}; /* default to black */
101 static int frame_topBand = 0;
102 static int frame_bottomBand = 0;
103 static int frame_leftBand = 0;
104 static int frame_rightBand = 0;
105 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
106 static int frame_rate = 25;
107 static int frame_rate_base = 1;
108 static float video_qscale = 0;
109 static int video_qmin = 2;
110 static int video_qmax = 31;
111 static int video_lmin = 2*FF_QP2LAMBDA;
112 static int video_lmax = 31*FF_QP2LAMBDA;
113 static int video_mb_lmin = 2*FF_QP2LAMBDA;
114 static int video_mb_lmax = 31*FF_QP2LAMBDA;
115 static int video_qdiff = 3;
116 static float video_qsquish = 0.0;
117 static uint16_t *intra_matrix = NULL;
118 static uint16_t *inter_matrix = NULL;
119 #if 0 //experimental, (can be removed)
120 static float video_rc_qsquish=1.0;
121 static float video_rc_qmod_amp=0;
122 static int video_rc_qmod_freq=0;
124 static char *video_rc_override_string=NULL;
125 static char *video_rc_eq="tex^qComp";
126 static int video_rc_buffer_size=0;
127 static float video_rc_buffer_aggressivity=1.0;
128 static float video_rc_initial_cplx=0;
129 static int me_method = ME_EPZS;
130 static int video_disable = 0;
131 static int video_discard = 0;
132 static int video_codec_id = CODEC_ID_NONE;
133 static int video_codec_tag = 0;
134 static int same_quality = 0;
135 static int b_frames = 0;
136 static int do_deinterlace = 0;
137 static int workaround_bugs = FF_BUG_AUTODETECT;
138 static int packet_size = 0;
139 static int error_rate = 0;
140 static int strict = 0;
141 static int top_field_first = -1;
142 static int sc_threshold = 0;
143 static int me_threshold = 0;
144 static int mb_threshold = 0;
145 static int intra_dc_precision = 8;
146 static int me_penalty_compensation= 256;
147 static int frame_skip_threshold= 0;
148 static int frame_skip_factor= 0;
149 static int frame_skip_exp= 0;
150 static int loop_input = 0;
151 static int loop_output = AVFMT_NOOUTPUTLOOP;
152 static int qp_hist = 0;
154 static int intra_only = 0;
155 static int audio_sample_rate = 44100;
156 static int audio_bit_rate = 64000;
157 #define QSCALE_NONE -99999
158 static float audio_qscale = QSCALE_NONE;
159 static int audio_disable = 0;
160 static int audio_channels = 1;
161 static int audio_codec_id = CODEC_ID_NONE;
162 static int audio_codec_tag = 0;
163 static char *audio_language = NULL;
165 static int subtitle_codec_id = CODEC_ID_NONE;
166 static char *subtitle_language = NULL;
168 static int mux_rate= 0;
169 static int mux_packet_size= 0;
170 static float mux_preload= 0.5;
171 static float mux_max_delay= 0.7;
173 static int64_t recording_time = 0;
174 static int64_t start_time = 0;
175 static int64_t rec_timestamp = 0;
176 static int64_t input_ts_offset = 0;
177 static int file_overwrite = 0;
178 static char *str_title = NULL;
179 static char *str_author = NULL;
180 static char *str_copyright = NULL;
181 static char *str_comment = NULL;
182 static char *str_album = NULL;
183 static int do_benchmark = 0;
184 static int do_hex_dump = 0;
185 static int do_pkt_dump = 0;
186 static int do_psnr = 0;
187 static int do_vstats = 0;
188 static int do_pass = 0;
189 static char *pass_logfilename = NULL;
190 static int audio_stream_copy = 0;
191 static int video_stream_copy = 0;
192 static int subtitle_stream_copy = 0;
193 static int video_sync_method= 1;
194 static int audio_sync_method= 0;
195 static int copy_ts= 0;
196 static int opt_shortest = 0; //
197 static int video_global_header = 0;
199 static int rate_emu = 0;
202 static const char *video_grab_format = "bktr";
204 #ifdef CONFIG_VIDEO4LINUX2
205 static const char *video_grab_format = "video4linux2";
207 static const char *video_grab_format = "video4linux";
210 static char *video_device = NULL;
211 static char *grab_device = NULL;
212 static int video_channel = 0;
213 static char *video_standard = "ntsc";
215 static const char *audio_grab_format = "audio_device";
216 static char *audio_device = NULL;
217 static int audio_volume = 256;
219 static int using_stdin = 0;
220 static int using_vhook = 0;
221 static int verbose = 1;
222 static int thread_count= 1;
223 static int q_pressed = 0;
224 static int64_t video_size = 0;
225 static int64_t audio_size = 0;
226 static int64_t extra_size = 0;
227 static int nb_frames_dup = 0;
228 static int nb_frames_drop = 0;
229 static int input_sync;
230 static int limit_filesize = 0; //
232 static int pgmyuv_compatibility_hack=0;
233 static int dts_delta_threshold = 10;
235 static int sws_flags = SWS_BICUBIC;
237 const char **opt_names=NULL;
238 int opt_name_count=0;
239 AVCodecContext *avctx_opts;
240 AVFormatContext *avformat_opts;
242 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
243 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
244 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
246 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
248 struct AVInputStream;
250 typedef struct AVOutputStream {
251 int file_index; /* file index */
252 int index; /* stream index in the output file */
253 int source_index; /* AVInputStream index */
254 AVStream *st; /* stream in the output file */
255 int encoding_needed; /* true if encoding needed for this stream */
257 /* input pts and corresponding output pts
259 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
260 struct AVInputStream *sync_ist; /* input stream to sync against */
261 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
264 AVFrame pict_tmp; /* temporary image for resampling */
265 struct SwsContext *img_resample_ctx; /* for image resampling */
269 int topBand; /* cropping area sizes */
273 int padtop; /* padding area sizes */
280 ReSampleContext *resample; /* for audio resampling */
281 FifoBuffer fifo; /* for compression: one audio fifo per codec */
285 typedef struct AVInputStream {
289 int discard; /* true if stream data should be discarded */
290 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
291 int64_t sample_index; /* current sample */
293 int64_t start; /* time when read started */
294 unsigned long frame; /* current frame */
295 int64_t next_pts; /* synthetic pts for cases where pkt.pts
297 int64_t pts; /* current pts */
298 int is_start; /* is 1 at the start and after a discontinuity */
301 typedef struct AVInputFile {
302 int eof_reached; /* true if eof reached */
303 int ist_index; /* index of first stream in ist_table */
304 int buffer_size; /* current total buffer size */
305 int buffer_size_max; /* buffer size at which we consider we can stop
307 int nb_streams; /* nb streams we are aware of */
312 /* init terminal so that we can grab keys */
313 static struct termios oldtty;
315 static void term_exit(void)
317 tcsetattr (0, TCSANOW, &oldtty);
320 static volatile sig_atomic_t received_sigterm = 0;
323 sigterm_handler(int sig)
325 received_sigterm = sig;
329 static void term_init(void)
336 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
337 |INLCR|IGNCR|ICRNL|IXON);
338 tty.c_oflag |= OPOST;
339 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
340 tty.c_cflag &= ~(CSIZE|PARENB);
345 tcsetattr (0, TCSANOW, &tty);
347 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
348 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
349 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
351 register a function to be called at normal program termination
354 #ifdef CONFIG_BEOS_NETSERVER
355 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
359 /* read a key without blocking */
360 static int read_key(void)
364 #ifndef CONFIG_BEOS_NETSERVER
372 n = select(1, &rfds, NULL, NULL, &tv);
384 static int decode_interrupt_cb(void)
386 return q_pressed || (q_pressed = read_key() == 'q');
391 static volatile int received_sigterm = 0;
393 /* no interactive support */
394 static void term_exit(void)
398 static void term_init(void)
402 static int read_key(void)
409 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
414 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
417 /* copy stream format */
418 s->nb_streams = ic->nb_streams;
419 for(i=0;i<ic->nb_streams;i++) {
422 // FIXME: a more elegant solution is needed
423 st = av_mallocz(sizeof(AVStream));
424 memcpy(st, ic->streams[i], sizeof(AVStream));
425 st->codec = avcodec_alloc_context();
426 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
430 av_close_input_file(ic);
435 get_sync_ipts(const AVOutputStream *ost)
437 const AVInputStream *ist = ost->sync_ist;
438 return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
441 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
443 AVPacket new_pkt= *pkt;
444 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
445 &new_pkt.data, &new_pkt.size,
446 pkt->data, pkt->size,
447 pkt->flags & PKT_FLAG_KEY);
450 new_pkt.destruct= av_destruct_packet;
457 av_interleaved_write_frame(s, pkt);
460 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
462 static void do_audio_out(AVFormatContext *s,
465 unsigned char *buf, int size)
468 static uint8_t *audio_buf = NULL;
469 static uint8_t *audio_out = NULL;
470 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
472 int size_out, frame_bytes, ret;
473 AVCodecContext *enc= ost->st->codec;
475 /* SC: dynamic allocation of buffers */
477 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
479 audio_out = av_malloc(audio_out_size);
480 if (!audio_buf || !audio_out)
481 return; /* Should signal an error ! */
483 if(audio_sync_method){
484 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
485 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2);
486 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
487 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
489 //FIXME resample delay
490 if(fabs(delta) > 50){
493 byte_delta= FFMAX(byte_delta, -size);
497 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
502 static uint8_t *input_tmp= NULL;
503 input_tmp= av_realloc(input_tmp, byte_delta + size);
505 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
508 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
510 memset(input_tmp, 0, byte_delta);
511 memcpy(input_tmp + byte_delta, buf, size);
515 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
517 }else if(audio_sync_method>1){
518 int comp= clip(delta, -audio_sync_method, audio_sync_method);
519 assert(ost->audio_resample);
521 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
522 // fprintf(stderr, "drift:%f len:%d opts:%lld ipts:%lld fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2));
523 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
527 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
528 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2); //FIXME wrong
530 if (ost->audio_resample) {
532 size_out = audio_resample(ost->resample,
533 (short *)buftmp, (short *)buf,
534 size / (ist->st->codec->channels * 2));
535 size_out = size_out * enc->channels * 2;
541 /* now encode as many frames as possible */
542 if (enc->frame_size > 1) {
543 /* output resampled raw samples */
544 fifo_write(&ost->fifo, buftmp, size_out,
547 frame_bytes = enc->frame_size * 2 * enc->channels;
549 while (fifo_read(&ost->fifo, audio_buf, frame_bytes,
550 &ost->fifo.rptr) == 0) {
552 av_init_packet(&pkt);
554 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
557 pkt.stream_index= ost->index;
560 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
561 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
562 pkt.flags |= PKT_FLAG_KEY;
563 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
565 ost->sync_opts += enc->frame_size;
569 av_init_packet(&pkt);
571 ost->sync_opts += size_out / (2 * enc->channels);
573 /* output a pcm frame */
574 /* XXX: change encoding codec API to avoid this ? */
575 switch(enc->codec->id) {
576 case CODEC_ID_PCM_S32LE:
577 case CODEC_ID_PCM_S32BE:
578 case CODEC_ID_PCM_U32LE:
579 case CODEC_ID_PCM_U32BE:
580 size_out = size_out << 1;
582 case CODEC_ID_PCM_S24LE:
583 case CODEC_ID_PCM_S24BE:
584 case CODEC_ID_PCM_U24LE:
585 case CODEC_ID_PCM_U24BE:
586 case CODEC_ID_PCM_S24DAUD:
587 size_out = size_out / 2 * 3;
589 case CODEC_ID_PCM_S16LE:
590 case CODEC_ID_PCM_S16BE:
591 case CODEC_ID_PCM_U16LE:
592 case CODEC_ID_PCM_U16BE:
595 size_out = size_out >> 1;
598 ret = avcodec_encode_audio(enc, audio_out, size_out,
601 pkt.stream_index= ost->index;
604 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
605 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
606 pkt.flags |= PKT_FLAG_KEY;
607 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
611 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
615 AVPicture picture_tmp;
618 dec = ist->st->codec;
620 /* deinterlace : must be done before any resize */
621 if (do_deinterlace || using_vhook) {
624 /* create temporary picture */
625 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
626 buf = av_malloc(size);
630 picture2 = &picture_tmp;
631 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
634 if(avpicture_deinterlace(picture2, picture,
635 dec->pix_fmt, dec->width, dec->height) < 0) {
636 /* if error, do not deinterlace */
642 img_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
648 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
650 if (picture != picture2)
651 *picture = *picture2;
655 /* we begin to correct av delay at this threshold */
656 #define AV_DELAY_MAX 0.100
658 static void do_subtitle_out(AVFormatContext *s,
664 static uint8_t *subtitle_out = NULL;
665 int subtitle_out_max_size = 65536;
666 int subtitle_out_size, nb, i;
670 if (pts == AV_NOPTS_VALUE) {
671 fprintf(stderr, "Subtitle packets must have a pts\n");
675 enc = ost->st->codec;
678 subtitle_out = av_malloc(subtitle_out_max_size);
681 /* Note: DVB subtitle need one packet to draw them and one other
682 packet to clear them */
683 /* XXX: signal it in the codec context ? */
684 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
689 for(i = 0; i < nb; i++) {
690 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
691 subtitle_out_max_size, sub);
693 av_init_packet(&pkt);
694 pkt.stream_index = ost->index;
695 pkt.data = subtitle_out;
696 pkt.size = subtitle_out_size;
697 pkt.pts = av_rescale_q(av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
698 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
699 /* XXX: the pts correction is handled here. Maybe handling
700 it in the codec would be better */
702 pkt.pts += 90 * sub->start_display_time;
704 pkt.pts += 90 * sub->end_display_time;
706 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
710 static int bit_buffer_size= 1024*256;
711 static uint8_t *bit_buffer= NULL;
713 static void do_video_out(AVFormatContext *s,
719 int nb_frames, i, ret;
720 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
721 AVFrame picture_crop_temp, picture_pad_temp;
722 uint8_t *buf = NULL, *buf1 = NULL;
723 AVCodecContext *enc, *dec;
725 avcodec_get_frame_defaults(&picture_crop_temp);
726 avcodec_get_frame_defaults(&picture_pad_temp);
728 enc = ost->st->codec;
729 dec = ist->st->codec;
731 /* by default, we output a single frame */
736 if(video_sync_method){
738 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
739 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
742 else if (vdelta > 1.1)
743 nb_frames = lrintf(vdelta);
744 //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);
748 fprintf(stderr, "*** drop!\n");
749 }else if (nb_frames > 1) {
750 nb_frames_dup += nb_frames;
752 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
755 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
757 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
761 if (ost->video_crop) {
762 if (img_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
763 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
766 formatted_picture = &picture_crop_temp;
768 formatted_picture = in_picture;
771 final_picture = formatted_picture;
772 padding_src = formatted_picture;
773 resampling_dst = &ost->pict_tmp;
774 if (ost->video_pad) {
775 final_picture = &ost->pict_tmp;
776 if (ost->video_resample) {
777 if (img_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
778 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
781 resampling_dst = &picture_pad_temp;
785 if (ost->video_resample) {
787 final_picture = &ost->pict_tmp;
788 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
789 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
792 if (ost->video_pad) {
793 img_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
794 enc->height, enc->width, enc->pix_fmt,
795 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
798 /* duplicates frame if needed */
799 for(i=0;i<nb_frames;i++) {
801 av_init_packet(&pkt);
802 pkt.stream_index= ost->index;
804 if (s->oformat->flags & AVFMT_RAWPICTURE) {
805 /* raw pictures are written as AVPicture structure to
806 avoid any copies. We support temorarily the older
808 AVFrame* old_frame = enc->coded_frame;
809 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
810 pkt.data= (uint8_t *)final_picture;
811 pkt.size= sizeof(AVPicture);
812 if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
813 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
814 if(dec->coded_frame && dec->coded_frame->key_frame)
815 pkt.flags |= PKT_FLAG_KEY;
817 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
818 enc->coded_frame = old_frame;
822 big_picture= *final_picture;
823 /* better than nothing: use input picture interlaced
825 big_picture.interlaced_frame = in_picture->interlaced_frame;
826 if(avctx_opts->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
827 if(top_field_first == -1)
828 big_picture.top_field_first = in_picture->top_field_first;
830 big_picture.top_field_first = top_field_first;
833 /* handles sameq here. This is not correct because it may
834 not be a global option */
836 big_picture.quality = ist->st->quality;
838 big_picture.quality = ost->st->quality;
840 big_picture.pict_type = 0;
841 // big_picture.pts = AV_NOPTS_VALUE;
842 big_picture.pts= ost->sync_opts;
843 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
844 //av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
845 ret = avcodec_encode_video(enc,
846 bit_buffer, bit_buffer_size,
848 //enc->frame_number = enc->real_pict_num;
850 pkt.data= bit_buffer;
852 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
853 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
854 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n",
855 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
856 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
858 if(enc->coded_frame && enc->coded_frame->key_frame)
859 pkt.flags |= PKT_FLAG_KEY;
860 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
862 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
863 // enc->frame_number-1, enc->real_pict_num, ret,
865 /* if two pass, output log */
866 if (ost->logfile && enc->stats_out) {
867 fprintf(ost->logfile, "%s", enc->stats_out);
879 static double psnr(double d){
880 if(d==0) return INFINITY;
881 return -10.0*log(d)/log(10.0);
884 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
887 static FILE *fvstats=NULL;
894 double ti1, bitrate, avg_bitrate;
898 today = localtime(&today2);
899 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
902 fvstats = fopen(filename,"w");
910 enc = ost->st->codec;
911 if (enc->codec_type == CODEC_TYPE_VIDEO) {
912 frame_number = ost->frame_number;
913 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
914 if (enc->flags&CODEC_FLAG_PSNR)
915 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
917 fprintf(fvstats,"f_size= %6d ", frame_size);
918 /* compute pts value */
919 ti1 = ost->sync_opts * av_q2d(enc->time_base);
923 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
924 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
925 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
926 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
927 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
931 static void print_report(AVFormatContext **output_files,
932 AVOutputStream **ost_table, int nb_ostreams,
937 AVFormatContext *oc, *os;
940 int frame_number, vid, i;
941 double bitrate, ti1, pts;
942 static int64_t last_time = -1;
943 static int qp_histogram[52];
945 if (!is_last_report) {
947 /* display the report every 0.5 seconds */
948 cur_time = av_gettime();
949 if (last_time == -1) {
950 last_time = cur_time;
953 if ((cur_time - last_time) < 500000)
955 last_time = cur_time;
959 oc = output_files[0];
961 total_size = url_ftell(&oc->pb);
966 for(i=0;i<nb_ostreams;i++) {
968 os = output_files[ost->file_index];
969 enc = ost->st->codec;
970 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
971 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
972 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
974 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
975 frame_number = ost->frame_number;
976 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%3.1f ",
977 frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
979 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
980 if(qp_hist && enc->coded_frame){
982 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
983 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
986 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
988 if (enc->flags&CODEC_FLAG_PSNR){
990 double error, error_sum=0;
991 double scale, scale_sum=0;
992 char type[3]= {'Y','U','V'};
993 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
996 error= enc->error[j];
997 scale= enc->width*enc->height*255.0*255.0*frame_number;
999 error= enc->coded_frame->error[j];
1000 scale= enc->width*enc->height*255.0*255.0;
1005 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1007 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1011 /* compute min output value */
1012 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1013 if ((pts < ti1) && (pts > 0))
1019 if (verbose || is_last_report) {
1020 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1022 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1023 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1024 (double)total_size / 1024, ti1, bitrate);
1027 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1028 nb_frames_dup, nb_frames_drop);
1031 fprintf(stderr, "%s \r", buf);
1036 if (is_last_report && verbose >= 0){
1037 int64_t raw= audio_size + video_size + extra_size;
1038 fprintf(stderr, "\n");
1039 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1043 100.0*(total_size - raw)/raw
1048 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1049 static int output_packet(AVInputStream *ist, int ist_index,
1050 AVOutputStream **ost_table, int nb_ostreams,
1051 const AVPacket *pkt)
1053 AVFormatContext *os;
1054 AVOutputStream *ost;
1058 int data_size, got_picture;
1060 void *buffer_to_free;
1061 static unsigned int samples_size= 0;
1062 static short *samples= NULL;
1063 AVSubtitle subtitle, *subtitle_to_free;
1067 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1068 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1069 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1071 // assert(ist->pts == ist->next_pts);
1085 /* decode the packet if needed */
1086 data_buf = NULL; /* fail safe */
1088 subtitle_to_free = NULL;
1089 if (ist->decoding_needed) {
1090 switch(ist->st->codec->codec_type) {
1091 case CODEC_TYPE_AUDIO:{
1093 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1094 /* XXX: could avoid copy if PCM 16 bits with same
1095 endianness as CPU */
1096 ret = avcodec_decode_audio(ist->st->codec, samples, &data_size,
1102 /* Some bug in mpeg audio decoder gives */
1103 /* data_size < 0, it seems they are overflows */
1104 if (data_size <= 0) {
1105 /* no audio frame */
1108 data_buf = (uint8_t *)samples;
1109 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1110 (ist->st->codec->sample_rate * ist->st->codec->channels);
1112 case CODEC_TYPE_VIDEO:
1113 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1114 /* XXX: allocate picture correctly */
1115 avcodec_get_frame_defaults(&picture);
1117 ret = avcodec_decode_video(ist->st->codec,
1118 &picture, &got_picture, ptr, len);
1119 ist->st->quality= picture.quality;
1123 /* no picture yet */
1124 goto discard_packet;
1126 if (ist->st->codec->time_base.num != 0) {
1127 ist->next_pts += ((int64_t)AV_TIME_BASE *
1128 ist->st->codec->time_base.num) /
1129 ist->st->codec->time_base.den;
1133 case CODEC_TYPE_SUBTITLE:
1134 ret = avcodec_decode_subtitle(ist->st->codec,
1135 &subtitle, &got_subtitle, ptr, len);
1138 if (!got_subtitle) {
1139 goto discard_packet;
1141 subtitle_to_free = &subtitle;
1148 switch(ist->st->codec->codec_type) {
1149 case CODEC_TYPE_AUDIO:
1150 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1151 (ist->st->codec->sample_rate * ist->st->codec->channels);
1153 case CODEC_TYPE_VIDEO:
1154 if (ist->st->codec->time_base.num != 0) {
1155 ist->next_pts += ((int64_t)AV_TIME_BASE *
1156 ist->st->codec->time_base.num) /
1157 ist->st->codec->time_base.den;
1167 buffer_to_free = NULL;
1168 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1169 pre_process_video_frame(ist, (AVPicture *)&picture,
1173 // preprocess audio (volume)
1174 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1175 if (audio_volume != 256) {
1178 for(i=0;i<(data_size / sizeof(short));i++) {
1179 int v = ((*volp) * audio_volume + 128) >> 8;
1180 if (v < -32768) v = -32768;
1181 if (v > 32767) v = 32767;
1187 /* frame rate emulation */
1188 if (ist->st->codec->rate_emu) {
1189 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1190 int64_t now = av_gettime() - ist->start;
1198 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1199 is the one of the next displayed one */
1200 /* XXX: add mpeg4 too ? */
1201 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1202 if (ist->st->codec->pict_type != B_TYPE) {
1204 tmp = ist->last_ip_pts;
1205 ist->last_ip_pts = ist->frac_pts.val;
1206 ist->frac_pts.val = tmp;
1210 /* if output time reached then transcode raw format,
1211 encode packets and output them */
1212 if (start_time == 0 || ist->pts >= start_time)
1213 for(i=0;i<nb_ostreams;i++) {
1217 if (ost->source_index == ist_index) {
1218 os = output_files[ost->file_index];
1221 printf("%d: got pts=%0.3f %0.3f\n", i,
1222 (double)pkt->pts / AV_TIME_BASE,
1223 ((double)ist->pts / AV_TIME_BASE) -
1224 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1226 /* set the input output pts pairs */
1227 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1229 if (ost->encoding_needed) {
1230 switch(ost->st->codec->codec_type) {
1231 case CODEC_TYPE_AUDIO:
1232 do_audio_out(os, ost, ist, data_buf, data_size);
1234 case CODEC_TYPE_VIDEO:
1235 do_video_out(os, ost, ist, &picture, &frame_size);
1236 video_size += frame_size;
1237 if (do_vstats && frame_size)
1238 do_video_stats(os, ost, frame_size);
1240 case CODEC_TYPE_SUBTITLE:
1241 do_subtitle_out(os, ost, ist, &subtitle,
1248 AVFrame avframe; //FIXME/XXX remove this
1250 av_init_packet(&opkt);
1252 /* no reencoding needed : output the packet directly */
1253 /* force the input stream PTS */
1255 avcodec_get_frame_defaults(&avframe);
1256 ost->st->codec->coded_frame= &avframe;
1257 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1259 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1260 audio_size += data_size;
1261 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1262 video_size += data_size;
1266 opkt.stream_index= ost->index;
1267 if(pkt->pts != AV_NOPTS_VALUE)
1268 opkt.pts= av_rescale_q(av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
1270 opkt.pts= AV_NOPTS_VALUE;
1274 if (pkt->dts == AV_NOPTS_VALUE)
1275 dts = ist->next_pts;
1277 dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1278 opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
1280 opkt.flags= pkt->flags;
1282 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1283 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1284 opkt.destruct= av_destruct_packet;
1286 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1287 ost->st->codec->frame_number++;
1288 ost->frame_number++;
1289 av_free_packet(&opkt);
1293 av_free(buffer_to_free);
1294 /* XXX: allocate the subtitles in the codec ? */
1295 if (subtitle_to_free) {
1296 if (subtitle_to_free->rects != NULL) {
1297 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1298 av_free(subtitle_to_free->rects[i].bitmap);
1299 av_free(subtitle_to_free->rects[i].rgba_palette);
1301 av_freep(&subtitle_to_free->rects);
1303 subtitle_to_free->num_rects = 0;
1304 subtitle_to_free = NULL;
1311 for(i=0;i<nb_ostreams;i++) {
1313 if (ost->source_index == ist_index) {
1314 AVCodecContext *enc= ost->st->codec;
1315 os = output_files[ost->file_index];
1317 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1319 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1322 if (ost->encoding_needed) {
1326 av_init_packet(&pkt);
1327 pkt.stream_index= ost->index;
1329 switch(ost->st->codec->codec_type) {
1330 case CODEC_TYPE_AUDIO:
1331 fifo_bytes = fifo_size(&ost->fifo, NULL);
1333 /* encode any samples remaining in fifo */
1334 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1335 int fs_tmp = enc->frame_size;
1336 enc->frame_size = fifo_bytes / (2 * enc->channels);
1337 if(fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes,
1338 &ost->fifo.rptr) == 0) {
1339 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1341 enc->frame_size = fs_tmp;
1344 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1347 pkt.flags |= PKT_FLAG_KEY;
1349 case CODEC_TYPE_VIDEO:
1350 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1352 if(enc->coded_frame && enc->coded_frame->key_frame)
1353 pkt.flags |= PKT_FLAG_KEY;
1354 if (ost->logfile && enc->stats_out) {
1355 fprintf(ost->logfile, "%s", enc->stats_out);
1364 pkt.data= bit_buffer;
1366 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1367 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1368 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1382 * The following code is the main loop of the file converter
1384 static int av_encode(AVFormatContext **output_files,
1385 int nb_output_files,
1386 AVFormatContext **input_files,
1388 AVStreamMap *stream_maps, int nb_stream_maps)
1390 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1391 AVFormatContext *is, *os;
1392 AVCodecContext *codec, *icodec;
1393 AVOutputStream *ost, **ost_table = NULL;
1394 AVInputStream *ist, **ist_table = NULL;
1395 AVInputFile *file_table;
1396 AVFormatContext *stream_no_data;
1399 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1403 /* input stream init */
1405 for(i=0;i<nb_input_files;i++) {
1406 is = input_files[i];
1407 file_table[i].ist_index = j;
1408 file_table[i].nb_streams = is->nb_streams;
1409 j += is->nb_streams;
1413 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1417 for(i=0;i<nb_istreams;i++) {
1418 ist = av_mallocz(sizeof(AVInputStream));
1424 for(i=0;i<nb_input_files;i++) {
1425 is = input_files[i];
1426 for(k=0;k<is->nb_streams;k++) {
1427 ist = ist_table[j++];
1428 ist->st = is->streams[k];
1429 ist->file_index = i;
1431 ist->discard = 1; /* the stream is discarded by default
1434 if (ist->st->codec->rate_emu) {
1435 ist->start = av_gettime();
1441 /* output stream init */
1443 for(i=0;i<nb_output_files;i++) {
1444 os = output_files[i];
1445 nb_ostreams += os->nb_streams;
1447 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1448 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1452 /* Sanity check the mapping args -- do the input files & streams exist? */
1453 for(i=0;i<nb_stream_maps;i++) {
1454 int fi = stream_maps[i].file_index;
1455 int si = stream_maps[i].stream_index;
1457 if (fi < 0 || fi > nb_input_files - 1 ||
1458 si < 0 || si > file_table[fi].nb_streams - 1) {
1459 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1462 fi = stream_maps[i].sync_file_index;
1463 si = stream_maps[i].sync_stream_index;
1464 if (fi < 0 || fi > nb_input_files - 1 ||
1465 si < 0 || si > file_table[fi].nb_streams - 1) {
1466 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1471 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1474 for(i=0;i<nb_ostreams;i++) {
1475 ost = av_mallocz(sizeof(AVOutputStream));
1482 for(k=0;k<nb_output_files;k++) {
1483 os = output_files[k];
1484 for(i=0;i<os->nb_streams;i++) {
1486 ost = ost_table[n++];
1487 ost->file_index = k;
1489 ost->st = os->streams[i];
1490 if (nb_stream_maps > 0) {
1491 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1492 stream_maps[n-1].stream_index;
1494 /* Sanity check that the stream types match */
1495 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1496 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1497 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1498 ost->file_index, ost->index);
1503 /* get corresponding input stream index : we select the first one with the right type */
1505 for(j=0;j<nb_istreams;j++) {
1508 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1509 ost->source_index = j;
1516 /* try again and reuse existing stream */
1517 for(j=0;j<nb_istreams;j++) {
1519 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1520 ost->source_index = j;
1525 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1526 ost->file_index, ost->index);
1531 ist = ist_table[ost->source_index];
1533 ost->sync_ist = (nb_stream_maps > 0) ?
1534 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1535 stream_maps[n-1].sync_stream_index] : ist;
1539 /* for each output stream, we compute the right encoding parameters */
1540 for(i=0;i<nb_ostreams;i++) {
1542 ist = ist_table[ost->source_index];
1544 codec = ost->st->codec;
1545 icodec = ist->st->codec;
1547 if (ost->st->stream_copy) {
1548 /* if stream_copy is selected, no need to decode or encode */
1549 codec->codec_id = icodec->codec_id;
1550 codec->codec_type = icodec->codec_type;
1551 if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1552 codec->bit_rate = icodec->bit_rate;
1553 codec->extradata= icodec->extradata;
1554 codec->extradata_size= icodec->extradata_size;
1555 codec->time_base = icodec->time_base;
1556 switch(codec->codec_type) {
1557 case CODEC_TYPE_AUDIO:
1558 codec->sample_rate = icodec->sample_rate;
1559 codec->channels = icodec->channels;
1560 codec->frame_size = icodec->frame_size;
1561 codec->block_align= icodec->block_align;
1563 case CODEC_TYPE_VIDEO:
1564 codec->pix_fmt = icodec->pix_fmt;
1565 codec->width = icodec->width;
1566 codec->height = icodec->height;
1567 codec->has_b_frames = icodec->has_b_frames;
1569 case CODEC_TYPE_SUBTITLE:
1575 switch(codec->codec_type) {
1576 case CODEC_TYPE_AUDIO:
1577 if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1580 if (codec->channels == icodec->channels &&
1581 codec->sample_rate == icodec->sample_rate) {
1582 ost->audio_resample = 0;
1584 if (codec->channels != icodec->channels &&
1585 (icodec->codec_id == CODEC_ID_AC3 ||
1586 icodec->codec_id == CODEC_ID_DTS)) {
1587 /* Special case for 5:1 AC3 and DTS input */
1588 /* and mono or stereo output */
1589 /* Request specific number of channels */
1590 icodec->channels = codec->channels;
1591 if (codec->sample_rate == icodec->sample_rate)
1592 ost->audio_resample = 0;
1594 ost->audio_resample = 1;
1597 ost->audio_resample = 1;
1600 if(audio_sync_method>1)
1601 ost->audio_resample = 1;
1603 if(ost->audio_resample){
1604 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1605 codec->sample_rate, icodec->sample_rate);
1607 printf("Can't resample. Aborting.\n");
1611 ist->decoding_needed = 1;
1612 ost->encoding_needed = 1;
1614 case CODEC_TYPE_VIDEO:
1615 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1616 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1617 ost->video_resample = ((codec->width != icodec->width -
1618 (frame_leftBand + frame_rightBand) +
1619 (frame_padleft + frame_padright)) ||
1620 (codec->height != icodec->height -
1621 (frame_topBand + frame_bottomBand) +
1622 (frame_padtop + frame_padbottom)) ||
1623 (codec->pix_fmt != icodec->pix_fmt));
1624 if (ost->video_crop) {
1625 ost->topBand = frame_topBand;
1626 ost->leftBand = frame_leftBand;
1628 if (ost->video_pad) {
1629 ost->padtop = frame_padtop;
1630 ost->padleft = frame_padleft;
1631 ost->padbottom = frame_padbottom;
1632 ost->padright = frame_padright;
1633 if (!ost->video_resample) {
1634 avcodec_get_frame_defaults(&ost->pict_tmp);
1635 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1636 codec->width, codec->height ) )
1640 if (ost->video_resample) {
1641 avcodec_get_frame_defaults(&ost->pict_tmp);
1642 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1643 codec->width, codec->height ) )
1646 ost->img_resample_ctx = sws_getContext(
1647 icodec->width - (frame_leftBand + frame_rightBand),
1648 icodec->height - (frame_topBand + frame_bottomBand),
1650 codec->width - (frame_padleft + frame_padright),
1651 codec->height - (frame_padtop + frame_padbottom),
1653 sws_flags, NULL, NULL, NULL);
1654 if (ost->img_resample_ctx == NULL) {
1655 fprintf(stderr, "Cannot get resampling context\n");
1658 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1660 ost->encoding_needed = 1;
1661 ist->decoding_needed = 1;
1663 case CODEC_TYPE_SUBTITLE:
1664 ost->encoding_needed = 1;
1665 ist->decoding_needed = 1;
1672 if (ost->encoding_needed &&
1673 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1674 char logfilename[1024];
1679 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1681 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1682 if (codec->flags & CODEC_FLAG_PASS1) {
1683 f = fopen(logfilename, "w");
1685 perror(logfilename);
1690 /* read the log file */
1691 f = fopen(logfilename, "r");
1693 perror(logfilename);
1696 fseek(f, 0, SEEK_END);
1698 fseek(f, 0, SEEK_SET);
1699 logbuffer = av_malloc(size + 1);
1701 fprintf(stderr, "Could not allocate log buffer\n");
1704 size = fread(logbuffer, 1, size, f);
1706 logbuffer[size] = '\0';
1707 codec->stats_in = logbuffer;
1711 if(codec->codec_type == CODEC_TYPE_VIDEO){
1712 int size= codec->width * codec->height;
1713 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1718 bit_buffer = av_malloc(bit_buffer_size);
1722 /* dump the file output parameters - cannot be done before in case
1724 for(i=0;i<nb_output_files;i++) {
1725 dump_format(output_files[i], i, output_files[i]->filename, 1);
1728 /* dump the stream mapping */
1730 fprintf(stderr, "Stream mapping:\n");
1731 for(i=0;i<nb_ostreams;i++) {
1733 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1734 ist_table[ost->source_index]->file_index,
1735 ist_table[ost->source_index]->index,
1738 if (ost->sync_ist != ist_table[ost->source_index])
1739 fprintf(stderr, " [sync #%d.%d]",
1740 ost->sync_ist->file_index,
1741 ost->sync_ist->index);
1742 fprintf(stderr, "\n");
1746 /* open each encoder */
1747 for(i=0;i<nb_ostreams;i++) {
1749 if (ost->encoding_needed) {
1751 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1753 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1754 ost->file_index, ost->index);
1757 if (avcodec_open(ost->st->codec, codec) < 0) {
1758 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1759 ost->file_index, ost->index);
1762 extra_size += ost->st->codec->extradata_size;
1766 /* open each decoder */
1767 for(i=0;i<nb_istreams;i++) {
1769 if (ist->decoding_needed) {
1771 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1773 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1774 ist->st->codec->codec_id, ist->file_index, ist->index);
1777 if (avcodec_open(ist->st->codec, codec) < 0) {
1778 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1779 ist->file_index, ist->index);
1782 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1783 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1788 for(i=0;i<nb_istreams;i++) {
1790 is = input_files[ist->file_index];
1792 ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1793 if(ist->st->start_time == AV_NOPTS_VALUE)
1795 if(input_files_ts_offset[ist->file_index])
1796 ist->next_pts= AV_NOPTS_VALUE;
1800 /* compute buffer size max (should use a complete heuristic) */
1801 for(i=0;i<nb_input_files;i++) {
1802 file_table[i].buffer_size_max = 2048;
1805 /* set meta data information from input file if required */
1806 for (i=0;i<nb_meta_data_maps;i++) {
1807 AVFormatContext *out_file;
1808 AVFormatContext *in_file;
1810 int out_file_index = meta_data_maps[i].out_file;
1811 int in_file_index = meta_data_maps[i].in_file;
1812 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1813 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1817 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1818 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1823 out_file = output_files[out_file_index];
1824 in_file = input_files[in_file_index];
1826 strcpy(out_file->title, in_file->title);
1827 strcpy(out_file->author, in_file->author);
1828 strcpy(out_file->copyright, in_file->copyright);
1829 strcpy(out_file->comment, in_file->comment);
1830 strcpy(out_file->album, in_file->album);
1831 out_file->year = in_file->year;
1832 out_file->track = in_file->track;
1833 strcpy(out_file->genre, in_file->genre);
1836 /* open files and write file headers */
1837 for(i=0;i<nb_output_files;i++) {
1838 os = output_files[i];
1839 if (av_write_header(os) < 0) {
1840 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1847 if ( !using_stdin && verbose >= 0) {
1848 fprintf(stderr, "Press [q] to stop encoding\n");
1849 url_set_interrupt_cb(decode_interrupt_cb);
1857 for(; received_sigterm == 0;) {
1858 int file_index, ist_index;
1866 /* if 'q' pressed, exits */
1870 /* read_key() returns 0 on EOF */
1876 /* select the stream that we must read now by looking at the
1877 smallest output pts */
1879 for(i=0;i<nb_ostreams;i++) {
1882 os = output_files[ost->file_index];
1883 ist = ist_table[ost->source_index];
1884 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1885 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1887 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1888 ipts = (double)ist->pts;
1889 if (!file_table[ist->file_index].eof_reached){
1890 if(ipts < ipts_min) {
1892 if(input_sync ) file_index = ist->file_index;
1894 if(opts < opts_min) {
1896 if(!input_sync) file_index = ist->file_index;
1899 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1904 /* if none, if is finished */
1905 if (file_index < 0) {
1909 /* finish if recording time exhausted */
1910 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1913 /* finish if limit size exhausted */
1914 if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1917 /* read a frame from it and output it in the fifo */
1918 is = input_files[file_index];
1919 if (av_read_frame(is, &pkt) < 0) {
1920 file_table[file_index].eof_reached = 1;
1921 if (opt_shortest) break; else continue; //
1925 stream_no_data = is;
1930 av_pkt_dump(stdout, &pkt, do_hex_dump);
1932 /* the following test is needed in case new streams appear
1933 dynamically in stream : we ignore them */
1934 if (pkt.stream_index >= file_table[file_index].nb_streams)
1935 goto discard_packet;
1936 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1937 ist = ist_table[ist_index];
1939 goto discard_packet;
1941 // 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);
1942 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1943 int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1944 if(ABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1945 input_files_ts_offset[ist->file_index]-= delta;
1947 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1948 for(i=0; i<file_table[file_index].nb_streams; i++){
1949 int index= file_table[file_index].ist_index + i;
1950 ist_table[index]->next_pts += delta;
1951 ist_table[index]->is_start=1;
1956 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1957 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1960 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1961 ist->file_index, ist->index);
1963 av_free_packet(&pkt);
1968 av_free_packet(&pkt);
1970 /* dump report by using the output first video and audio streams */
1971 print_report(output_files, ost_table, nb_ostreams, 0);
1974 /* at the end of stream, we must flush the decoder buffers */
1975 for(i=0;i<nb_istreams;i++) {
1977 if (ist->decoding_needed) {
1978 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1984 /* write the trailer if needed and close file */
1985 for(i=0;i<nb_output_files;i++) {
1986 os = output_files[i];
1987 av_write_trailer(os);
1990 /* dump report by using the first video and audio streams */
1991 print_report(output_files, ost_table, nb_ostreams, 1);
1993 /* close each encoder */
1994 for(i=0;i<nb_ostreams;i++) {
1996 if (ost->encoding_needed) {
1997 av_freep(&ost->st->codec->stats_in);
1998 avcodec_close(ost->st->codec);
2002 /* close each decoder */
2003 for(i=0;i<nb_istreams;i++) {
2005 if (ist->decoding_needed) {
2006 avcodec_close(ist->st->codec);
2014 av_freep(&bit_buffer);
2015 av_free(file_table);
2018 for(i=0;i<nb_istreams;i++) {
2025 for(i=0;i<nb_ostreams;i++) {
2029 fclose(ost->logfile);
2030 ost->logfile = NULL;
2032 fifo_free(&ost->fifo); /* works even if fifo is not
2033 initialized but set to zero */
2034 av_free(ost->pict_tmp.data[0]);
2035 if (ost->video_resample)
2036 sws_freeContext(ost->img_resample_ctx);
2037 if (ost->audio_resample)
2038 audio_resample_close(ost->resample);
2051 int file_read(const char *filename)
2054 unsigned char buffer[1024];
2057 if (url_open(&h, filename, O_RDONLY) < 0) {
2058 printf("could not open '%s'\n", filename);
2062 len = url_read(h, buffer, sizeof(buffer));
2065 for(i=0;i<len;i++) putchar(buffer[i]);
2072 static void opt_image_format(const char *arg)
2076 for(f = first_image_format; f != NULL; f = f->next) {
2077 if (!strcmp(arg, f->name))
2081 fprintf(stderr, "Unknown image format: '%s'\n", arg);
2087 static void opt_format(const char *arg)
2089 /* compatibility stuff for pgmyuv */
2090 if (!strcmp(arg, "pgmyuv")) {
2091 pgmyuv_compatibility_hack=1;
2092 // opt_image_format(arg);
2096 file_iformat = av_find_input_format(arg);
2097 file_oformat = guess_format(arg, NULL, NULL);
2098 if (!file_iformat && !file_oformat) {
2099 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2104 static void opt_video_buffer_size(const char *arg)
2106 video_rc_buffer_size = atoi(arg) * 8*1024;
2109 static void opt_video_rc_eq(char *arg)
2114 static void opt_video_rc_override_string(char *arg)
2116 video_rc_override_string = arg;
2120 static void opt_workaround_bugs(const char *arg)
2122 workaround_bugs = atoi(arg);
2125 static void opt_me_threshold(const char *arg)
2127 me_threshold = atoi(arg);
2130 static void opt_mb_threshold(const char *arg)
2132 mb_threshold = atoi(arg);
2135 static void opt_verbose(const char *arg)
2137 verbose = atoi(arg);
2138 av_log_set_level(atoi(arg));
2141 static void opt_frame_rate(const char *arg)
2143 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2144 fprintf(stderr, "Incorrect frame rate\n");
2149 static void opt_frame_crop_top(const char *arg)
2151 frame_topBand = atoi(arg);
2152 if (frame_topBand < 0) {
2153 fprintf(stderr, "Incorrect top crop size\n");
2156 if ((frame_topBand % 2) != 0) {
2157 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2160 if ((frame_topBand) >= frame_height){
2161 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2164 frame_height -= frame_topBand;
2167 static void opt_frame_crop_bottom(const char *arg)
2169 frame_bottomBand = atoi(arg);
2170 if (frame_bottomBand < 0) {
2171 fprintf(stderr, "Incorrect bottom crop size\n");
2174 if ((frame_bottomBand % 2) != 0) {
2175 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2178 if ((frame_bottomBand) >= frame_height){
2179 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2182 frame_height -= frame_bottomBand;
2185 static void opt_frame_crop_left(const char *arg)
2187 frame_leftBand = atoi(arg);
2188 if (frame_leftBand < 0) {
2189 fprintf(stderr, "Incorrect left crop size\n");
2192 if ((frame_leftBand % 2) != 0) {
2193 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2196 if ((frame_leftBand) >= frame_width){
2197 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2200 frame_width -= frame_leftBand;
2203 static void opt_frame_crop_right(const char *arg)
2205 frame_rightBand = atoi(arg);
2206 if (frame_rightBand < 0) {
2207 fprintf(stderr, "Incorrect right crop size\n");
2210 if ((frame_rightBand % 2) != 0) {
2211 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2214 if ((frame_rightBand) >= frame_width){
2215 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2218 frame_width -= frame_rightBand;
2221 static void opt_frame_size(const char *arg)
2223 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2224 fprintf(stderr, "Incorrect frame size\n");
2227 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2228 fprintf(stderr, "Frame size must be a multiple of 2\n");
2234 #define SCALEBITS 10
2235 #define ONE_HALF (1 << (SCALEBITS - 1))
2236 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2238 #define RGB_TO_Y(r, g, b) \
2239 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2240 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2242 #define RGB_TO_U(r1, g1, b1, shift)\
2243 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2244 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2246 #define RGB_TO_V(r1, g1, b1, shift)\
2247 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2248 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2250 static void opt_pad_color(const char *arg) {
2251 /* Input is expected to be six hex digits similar to
2252 how colors are expressed in html tags (but without the #) */
2253 int rgb = strtol(arg, NULL, 16);
2257 g = ((rgb >> 8) & 255);
2260 padcolor[0] = RGB_TO_Y(r,g,b);
2261 padcolor[1] = RGB_TO_U(r,g,b,0);
2262 padcolor[2] = RGB_TO_V(r,g,b,0);
2265 static void opt_frame_pad_top(const char *arg)
2267 frame_padtop = atoi(arg);
2268 if (frame_padtop < 0) {
2269 fprintf(stderr, "Incorrect top pad size\n");
2272 if ((frame_padtop % 2) != 0) {
2273 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2278 static void opt_frame_pad_bottom(const char *arg)
2280 frame_padbottom = atoi(arg);
2281 if (frame_padbottom < 0) {
2282 fprintf(stderr, "Incorrect bottom pad size\n");
2285 if ((frame_padbottom % 2) != 0) {
2286 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2292 static void opt_frame_pad_left(const char *arg)
2294 frame_padleft = atoi(arg);
2295 if (frame_padleft < 0) {
2296 fprintf(stderr, "Incorrect left pad size\n");
2299 if ((frame_padleft % 2) != 0) {
2300 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2306 static void opt_frame_pad_right(const char *arg)
2308 frame_padright = atoi(arg);
2309 if (frame_padright < 0) {
2310 fprintf(stderr, "Incorrect right pad size\n");
2313 if ((frame_padright % 2) != 0) {
2314 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2320 static void opt_frame_pix_fmt(const char *arg)
2322 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2325 static void opt_frame_aspect_ratio(const char *arg)
2331 p = strchr(arg, ':');
2333 x = strtol(arg, (char **)&arg, 10);
2335 y = strtol(arg+1, (char **)&arg, 10);
2337 ar = (double)x / (double)y;
2339 ar = strtod(arg, (char **)&arg);
2342 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2345 frame_aspect_ratio = ar;
2348 static void opt_b_frames(const char *arg)
2350 b_frames = atoi(arg);
2351 if (b_frames > FF_MAX_B_FRAMES) {
2352 fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2354 } else if (b_frames < 1) {
2355 fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2360 static void opt_qscale(const char *arg)
2362 video_qscale = atof(arg);
2363 if (video_qscale <= 0 ||
2364 video_qscale > 255) {
2365 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2370 static void opt_qsquish(const char *arg)
2372 video_qsquish = atof(arg);
2373 if (video_qsquish < 0.0 ||
2374 video_qsquish > 99.0) {
2375 fprintf(stderr, "qsquish must be >= 0.0 and <= 99.0\n");
2380 static void opt_lmax(const char *arg)
2382 video_lmax = atof(arg)*FF_QP2LAMBDA;
2385 static void opt_lmin(const char *arg)
2387 video_lmin = atof(arg)*FF_QP2LAMBDA;
2390 static void opt_qmin(const char *arg)
2392 video_qmin = atoi(arg);
2393 if (video_qmin < 1 ||
2395 fprintf(stderr, "qmin must be >= 1 and <= 51\n");
2400 static void opt_qmax(const char *arg)
2402 video_qmax = atoi(arg);
2403 if (video_qmax < 1 ||
2405 fprintf(stderr, "qmax must be >= 1 and <= 51\n");
2410 static void opt_mb_lmin(const char *arg)
2412 video_mb_lmin = atof(arg)*FF_QP2LAMBDA;
2413 if (video_mb_lmin < 1 ||
2414 video_mb_lmin > FF_LAMBDA_MAX) {
2415 fprintf(stderr, "mblmin must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2420 static void opt_mb_lmax(const char *arg)
2422 video_mb_lmax = atof(arg)*FF_QP2LAMBDA;
2423 if (video_mb_lmax < 1 ||
2424 video_mb_lmax > FF_LAMBDA_MAX) {
2425 fprintf(stderr, "mblmax must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2430 static void opt_qdiff(const char *arg)
2432 video_qdiff = atoi(arg);
2433 if (video_qdiff < 0 ||
2435 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2440 static void opt_rc_initial_cplx(const char *arg)
2442 video_rc_initial_cplx = atof(arg);
2445 static void opt_packet_size(const char *arg)
2447 packet_size= atoi(arg);
2450 static void opt_error_rate(const char *arg)
2452 error_rate= atoi(arg);
2455 static void opt_strict(const char *arg)
2460 static void opt_top_field_first(const char *arg)
2462 top_field_first= atoi(arg);
2465 static void opt_sc_threshold(const char *arg)
2467 sc_threshold= atoi(arg);
2470 static void opt_thread_count(const char *arg)
2472 thread_count= atoi(arg);
2473 #if !defined(HAVE_THREADS)
2475 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2479 static void opt_audio_bitrate(const char *arg)
2481 audio_bit_rate = atoi(arg) * 1000;
2484 static void opt_audio_rate(const char *arg)
2486 audio_sample_rate = atoi(arg);
2489 static void opt_audio_channels(const char *arg)
2491 audio_channels = atoi(arg);
2494 static void opt_video_device(const char *arg)
2496 video_device = av_strdup(arg);
2499 static void opt_grab_device(const char *arg)
2501 grab_device = av_strdup(arg);
2504 static void opt_video_channel(const char *arg)
2506 video_channel = strtol(arg, NULL, 0);
2509 static void opt_video_standard(const char *arg)
2511 video_standard = av_strdup(arg);
2514 static void opt_audio_device(const char *arg)
2516 audio_device = av_strdup(arg);
2519 static void opt_codec(int *pstream_copy, int *pcodec_id,
2520 int codec_type, const char *arg)
2524 if (!strcmp(arg, "copy")) {
2529 if (!strcmp(p->name, arg) && p->type == codec_type)
2534 fprintf(stderr, "Unknown codec '%s'\n", arg);
2542 static void opt_audio_codec(const char *arg)
2544 opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2547 static void opt_audio_tag(const char *arg)
2550 audio_codec_tag= strtol(arg, &tail, 0);
2553 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2556 static void opt_video_tag(const char *arg)
2559 video_codec_tag= strtol(arg, &tail, 0);
2562 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2565 static void add_frame_hooker(const char *arg)
2570 char *args = av_strdup(arg);
2574 argv[0] = strtok(args, " ");
2575 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2578 i = frame_hook_add(argc, argv);
2581 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2586 const char *motion_str[] = {
2599 static void opt_motion_estimation(const char *arg)
2605 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2608 if (!strcmp(*p, arg))
2612 me_method = (p - motion_str) + 1;
2615 static void opt_video_codec(const char *arg)
2617 opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2620 static void opt_subtitle_codec(const char *arg)
2622 opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2625 static void opt_map(const char *arg)
2631 m = &stream_maps[nb_stream_maps++];
2633 m->file_index = strtol(arg, (char **)&p, 0);
2637 m->stream_index = strtol(p, (char **)&p, 0);
2640 m->sync_file_index = strtol(p, (char **)&p, 0);
2643 m->sync_stream_index = strtol(p, (char **)&p, 0);
2645 m->sync_file_index = m->file_index;
2646 m->sync_stream_index = m->stream_index;
2650 static void opt_map_meta_data(const char *arg)
2656 m = &meta_data_maps[nb_meta_data_maps++];
2658 m->out_file = strtol(arg, (char **)&p, 0);
2662 m->in_file = strtol(p, (char **)&p, 0);
2665 static void opt_recording_time(const char *arg)
2667 recording_time = parse_date(arg, 1);
2670 static void opt_start_time(const char *arg)
2672 start_time = parse_date(arg, 1);
2675 static void opt_rec_timestamp(const char *arg)
2677 rec_timestamp = parse_date(arg, 0) / 1000000;
2680 static void opt_input_ts_offset(const char *arg)
2682 input_ts_offset = parse_date(arg, 1);
2685 static void opt_input_file(const char *filename)
2687 AVFormatContext *ic;
2688 AVFormatParameters params, *ap = ¶ms;
2689 int err, i, ret, rfps, rfps_base;
2692 if (!strcmp(filename, "-"))
2695 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2696 !strcmp( filename, "/dev/stdin" );
2698 /* get default parameters from command line */
2699 ic = av_alloc_format_context();
2701 memset(ap, 0, sizeof(*ap));
2702 ap->prealloced_context = 1;
2703 ap->sample_rate = audio_sample_rate;
2704 ap->channels = audio_channels;
2705 ap->time_base.den = frame_rate;
2706 ap->time_base.num = frame_rate_base;
2707 ap->width = frame_width + frame_padleft + frame_padright;
2708 ap->height = frame_height + frame_padtop + frame_padbottom;
2709 ap->image_format = image_format;
2710 ap->pix_fmt = frame_pix_fmt;
2711 ap->device = grab_device;
2712 ap->channel = video_channel;
2713 ap->standard = video_standard;
2714 ap->video_codec_id = video_codec_id;
2715 ap->audio_codec_id = audio_codec_id;
2716 if(pgmyuv_compatibility_hack)
2717 ap->video_codec_id= CODEC_ID_PGMYUV;
2719 for(i=0; i<opt_name_count; i++){
2721 double d= av_get_double(avformat_opts, opt_names[i], &opt);
2722 if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2723 av_set_double(ic, opt_names[i], d);
2725 /* open the input file with generic libav function */
2726 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2728 print_error(filename, err);
2732 ic->loop_input = loop_input;
2734 /* If not enough info to get the stream parameters, we decode the
2735 first frames to get it. (used in mpeg case for example) */
2736 ret = av_find_stream_info(ic);
2737 if (ret < 0 && verbose >= 0) {
2738 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2742 timestamp = start_time;
2743 /* add the stream start time */
2744 if (ic->start_time != AV_NOPTS_VALUE)
2745 timestamp += ic->start_time;
2747 /* if seeking requested, we execute it */
2748 if (start_time != 0) {
2749 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2751 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2752 filename, (double)timestamp / AV_TIME_BASE);
2754 /* reset seek info */
2758 /* update the current parameters so that they match the one of the input stream */
2759 for(i=0;i<ic->nb_streams;i++) {
2761 AVCodecContext *enc = ic->streams[i]->codec;
2762 #if defined(HAVE_THREADS)
2764 avcodec_thread_init(enc, thread_count);
2766 enc->thread_count= thread_count;
2767 switch(enc->codec_type) {
2768 case CODEC_TYPE_AUDIO:
2769 for(j=0; j<opt_name_count; j++){
2771 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2772 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2773 av_set_double(enc, opt_names[j], d);
2775 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2776 audio_channels = enc->channels;
2777 audio_sample_rate = enc->sample_rate;
2779 ic->streams[i]->discard= AVDISCARD_ALL;
2781 case CODEC_TYPE_VIDEO:
2782 for(j=0; j<opt_name_count; j++){
2784 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2785 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2786 av_set_double(enc, opt_names[j], d);
2788 frame_height = enc->height;
2789 frame_width = enc->width;
2790 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2791 frame_pix_fmt = enc->pix_fmt;
2792 rfps = ic->streams[i]->r_frame_rate.num;
2793 rfps_base = ic->streams[i]->r_frame_rate.den;
2794 enc->workaround_bugs = workaround_bugs;
2795 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2797 enc->debug |= FF_DEBUG_MV;
2799 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2802 fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2803 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2805 (float)rfps / rfps_base, rfps, rfps_base);
2807 /* update the current frame rate to match the stream frame rate */
2809 frame_rate_base = rfps_base;
2811 enc->rate_emu = rate_emu;
2813 ic->streams[i]->discard= AVDISCARD_ALL;
2814 else if(video_discard)
2815 ic->streams[i]->discard= video_discard;
2817 case CODEC_TYPE_DATA:
2819 case CODEC_TYPE_SUBTITLE:
2821 case CODEC_TYPE_UNKNOWN:
2828 input_files[nb_input_files] = ic;
2829 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2830 /* dump the file content */
2832 dump_format(ic, nb_input_files, filename, 0);
2835 file_iformat = NULL;
2836 file_oformat = NULL;
2837 image_format = NULL;
2845 static void opt_grab(const char *arg)
2847 file_iformat = av_find_input_format(arg);
2851 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2853 int has_video, has_audio, i, j;
2854 AVFormatContext *ic;
2858 for(j=0;j<nb_input_files;j++) {
2859 ic = input_files[j];
2860 for(i=0;i<ic->nb_streams;i++) {
2861 AVCodecContext *enc = ic->streams[i]->codec;
2862 switch(enc->codec_type) {
2863 case CODEC_TYPE_AUDIO:
2866 case CODEC_TYPE_VIDEO:
2869 case CODEC_TYPE_DATA:
2870 case CODEC_TYPE_UNKNOWN:
2871 case CODEC_TYPE_SUBTITLE:
2878 *has_video_ptr = has_video;
2879 *has_audio_ptr = has_audio;
2882 static void new_video_stream(AVFormatContext *oc)
2885 AVCodecContext *video_enc;
2888 st = av_new_stream(oc, oc->nb_streams);
2890 fprintf(stderr, "Could not alloc stream\n");
2893 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2894 video_bitstream_filters= NULL;
2896 #if defined(HAVE_THREADS)
2898 avcodec_thread_init(st->codec, thread_count);
2901 video_enc = st->codec;
2904 video_enc->codec_tag= video_codec_tag;
2906 if( (video_global_header&1)
2907 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2908 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2909 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2911 if(video_global_header&2){
2912 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2913 avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2916 if (video_stream_copy) {
2917 st->stream_copy = 1;
2918 video_enc->codec_type = CODEC_TYPE_VIDEO;
2924 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2925 if (video_codec_id != CODEC_ID_NONE)
2926 codec_id = video_codec_id;
2928 video_enc->codec_id = codec_id;
2929 codec = avcodec_find_encoder(codec_id);
2931 for(i=0; i<opt_name_count; i++){
2933 double d= av_get_double(avctx_opts, opt_names[i], &opt);
2934 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2935 av_set_double(video_enc, opt_names[i], d);
2938 video_enc->time_base.den = frame_rate;
2939 video_enc->time_base.num = frame_rate_base;
2940 if(codec && codec->supported_framerates){
2941 const AVRational *p= codec->supported_framerates;
2942 AVRational req= (AVRational){frame_rate, frame_rate_base};
2943 const AVRational *best=NULL;
2944 AVRational best_error= (AVRational){INT_MAX, 1};
2945 for(; p->den!=0; p++){
2946 AVRational error= av_sub_q(req, *p);
2947 if(error.num <0) error.num *= -1;
2948 if(av_cmp_q(error, best_error) < 0){
2953 video_enc->time_base.den= best->num;
2954 video_enc->time_base.num= best->den;
2957 video_enc->width = frame_width + frame_padright + frame_padleft;
2958 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2959 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2960 video_enc->pix_fmt = frame_pix_fmt;
2962 if(codec && codec->pix_fmts){
2963 const enum PixelFormat *p= codec->pix_fmts;
2965 if(*p == video_enc->pix_fmt)
2969 video_enc->pix_fmt = codec->pix_fmts[0];
2973 video_enc->gop_size = 0;
2974 if (video_qscale || same_quality) {
2975 video_enc->flags |= CODEC_FLAG_QSCALE;
2976 video_enc->global_quality=
2977 st->quality = FF_QP2LAMBDA * video_qscale;
2981 video_enc->intra_matrix = intra_matrix;
2983 video_enc->inter_matrix = inter_matrix;
2985 video_enc->max_b_frames = b_frames;
2986 video_enc->qmin = video_qmin;
2987 video_enc->qmax = video_qmax;
2988 video_enc->lmin = video_lmin;
2989 video_enc->lmax = video_lmax;
2990 video_enc->rc_qsquish = video_qsquish;
2991 video_enc->mb_lmin = video_mb_lmin;
2992 video_enc->mb_lmax = video_mb_lmax;
2993 video_enc->max_qdiff = video_qdiff;
2994 video_enc->rc_eq = video_rc_eq;
2995 video_enc->workaround_bugs = workaround_bugs;
2996 video_enc->thread_count = thread_count;
2997 p= video_rc_override_string;
3000 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3002 fprintf(stderr, "error parsing rc_override\n");
3005 video_enc->rc_override=
3006 av_realloc(video_enc->rc_override,
3007 sizeof(RcOverride)*(i+1));
3008 video_enc->rc_override[i].start_frame= start;
3009 video_enc->rc_override[i].end_frame = end;
3011 video_enc->rc_override[i].qscale= q;
3012 video_enc->rc_override[i].quality_factor= 1.0;
3015 video_enc->rc_override[i].qscale= 0;
3016 video_enc->rc_override[i].quality_factor= -q/100.0;
3021 video_enc->rc_override_count=i;
3023 video_enc->rc_buffer_size = video_rc_buffer_size;
3024 video_enc->rc_initial_buffer_occupancy = video_rc_buffer_size*3/4;
3025 video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
3026 video_enc->rc_initial_cplx= video_rc_initial_cplx;
3027 video_enc->me_threshold= me_threshold;
3028 video_enc->mb_threshold= mb_threshold;
3029 video_enc->intra_dc_precision= intra_dc_precision - 8;
3030 video_enc->strict_std_compliance = strict;
3031 video_enc->error_rate = error_rate;
3032 video_enc->scenechange_threshold= sc_threshold;
3033 video_enc->me_penalty_compensation= me_penalty_compensation;
3034 video_enc->frame_skip_threshold= frame_skip_threshold;
3035 video_enc->frame_skip_factor= frame_skip_factor;
3036 video_enc->frame_skip_exp= frame_skip_exp;
3039 video_enc->rtp_mode= 1;
3040 video_enc->rtp_payload_size= packet_size;
3044 video_enc->flags|= CODEC_FLAG_PSNR;
3046 video_enc->me_method = me_method;
3051 video_enc->flags |= CODEC_FLAG_PASS1;
3053 video_enc->flags |= CODEC_FLAG_PASS2;
3058 /* reset some key parameters */
3060 video_codec_id = CODEC_ID_NONE;
3061 video_stream_copy = 0;
3064 static void new_audio_stream(AVFormatContext *oc)
3067 AVCodecContext *audio_enc;
3070 st = av_new_stream(oc, oc->nb_streams);
3072 fprintf(stderr, "Could not alloc stream\n");
3076 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3077 audio_bitstream_filters= NULL;
3079 #if defined(HAVE_THREADS)
3081 avcodec_thread_init(st->codec, thread_count);
3084 audio_enc = st->codec;
3085 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3088 audio_enc->codec_tag= audio_codec_tag;
3090 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3091 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3092 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
3094 if (audio_stream_copy) {
3095 st->stream_copy = 1;
3096 audio_enc->channels = audio_channels;
3098 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3100 for(i=0; i<opt_name_count; i++){
3102 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3103 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3104 av_set_double(audio_enc, opt_names[i], d);
3107 if (audio_codec_id != CODEC_ID_NONE)
3108 codec_id = audio_codec_id;
3109 audio_enc->codec_id = codec_id;
3111 audio_enc->bit_rate = audio_bit_rate;
3112 if (audio_qscale > QSCALE_NONE) {
3113 audio_enc->flags |= CODEC_FLAG_QSCALE;
3114 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3116 audio_enc->strict_std_compliance = strict;
3117 audio_enc->thread_count = thread_count;
3118 /* For audio codecs other than AC3 or DTS we limit */
3119 /* the number of coded channels to stereo */
3120 if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3121 && codec_id != CODEC_ID_DTS) {
3122 audio_enc->channels = 2;
3124 audio_enc->channels = audio_channels;
3126 audio_enc->sample_rate = audio_sample_rate;
3127 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3128 if (audio_language) {
3129 pstrcpy(st->language, sizeof(st->language), audio_language);
3130 av_free(audio_language);
3131 audio_language = NULL;
3134 /* reset some key parameters */
3136 audio_codec_id = CODEC_ID_NONE;
3137 audio_stream_copy = 0;
3140 static void opt_new_subtitle_stream(void)
3142 AVFormatContext *oc;
3144 AVCodecContext *subtitle_enc;
3147 if (nb_output_files <= 0) {
3148 fprintf(stderr, "At least one output file must be specified\n");
3151 oc = output_files[nb_output_files - 1];
3153 st = av_new_stream(oc, oc->nb_streams);
3155 fprintf(stderr, "Could not alloc stream\n");
3159 subtitle_enc = st->codec;
3160 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3161 if (subtitle_stream_copy) {
3162 st->stream_copy = 1;
3164 for(i=0; i<opt_name_count; i++){
3166 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3167 if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3168 av_set_double(subtitle_enc, opt_names[i], d);
3170 subtitle_enc->codec_id = subtitle_codec_id;
3173 if (subtitle_language) {
3174 pstrcpy(st->language, sizeof(st->language), subtitle_language);
3175 av_free(subtitle_language);
3176 subtitle_language = NULL;
3179 subtitle_codec_id = CODEC_ID_NONE;
3180 subtitle_stream_copy = 0;
3183 static void opt_new_audio_stream(void)
3185 AVFormatContext *oc;
3186 if (nb_output_files <= 0) {
3187 fprintf(stderr, "At least one output file must be specified\n");
3190 oc = output_files[nb_output_files - 1];
3191 new_audio_stream(oc);
3194 static void opt_new_video_stream(void)
3196 AVFormatContext *oc;
3197 if (nb_output_files <= 0) {
3198 fprintf(stderr, "At least one output file must be specified\n");
3201 oc = output_files[nb_output_files - 1];
3202 new_video_stream(oc);
3205 static void opt_output_file(const char *filename)
3207 AVFormatContext *oc;
3208 int use_video, use_audio, input_has_video, input_has_audio, i;
3209 AVFormatParameters params, *ap = ¶ms;
3211 if (!strcmp(filename, "-"))
3214 oc = av_alloc_format_context();
3216 if (!file_oformat) {
3217 file_oformat = guess_format(NULL, filename, NULL);
3218 if (!file_oformat) {
3219 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3225 oc->oformat = file_oformat;
3226 pstrcpy(oc->filename, sizeof(oc->filename), filename);
3228 if (!strcmp(file_oformat->name, "ffm") &&
3229 strstart(filename, "http:", NULL)) {
3230 /* special case for files sent to ffserver: we get the stream
3231 parameters from ffserver */
3232 if (read_ffserver_streams(oc, filename) < 0) {
3233 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3237 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3238 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3240 /* disable if no corresponding type found and at least one
3242 if (nb_input_files > 0) {
3243 check_audio_video_inputs(&input_has_video, &input_has_audio);
3244 if (!input_has_video)
3246 if (!input_has_audio)
3250 /* manual disable */
3251 if (audio_disable) {
3254 if (video_disable) {
3259 new_video_stream(oc);
3263 new_audio_stream(oc);
3266 if (!oc->nb_streams) {
3267 fprintf(stderr, "No audio or video streams available\n");
3271 oc->timestamp = rec_timestamp;
3274 pstrcpy(oc->title, sizeof(oc->title), str_title);
3276 pstrcpy(oc->author, sizeof(oc->author), str_author);
3278 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3280 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3282 pstrcpy(oc->album, sizeof(oc->album), str_album);
3285 output_files[nb_output_files++] = oc;
3287 /* check filename in case of an image number is expected */
3288 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3289 if (!av_filename_number_test(oc->filename)) {
3290 print_error(oc->filename, AVERROR_NUMEXPECTED);
3295 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3296 /* test if it already exists to avoid loosing precious files */
3297 if (!file_overwrite &&
3298 (strchr(filename, ':') == NULL ||
3299 strstart(filename, "file:", NULL))) {
3300 if (url_exist(filename)) {
3303 if ( !using_stdin ) {
3304 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3307 if (toupper(c) != 'Y') {
3308 fprintf(stderr, "Not overwriting - exiting\n");
3313 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3320 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3321 fprintf(stderr, "Could not open '%s'\n", filename);
3326 memset(ap, 0, sizeof(*ap));
3327 ap->image_format = image_format;
3328 if (av_set_parameters(oc, ap) < 0) {
3329 fprintf(stderr, "%s: Invalid encoding parameters\n",
3334 oc->packet_size= mux_packet_size;
3335 oc->mux_rate= mux_rate;
3336 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3337 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3338 oc->loop_output = loop_output;
3340 for(i=0; i<opt_name_count; i++){
3342 double d = av_get_double(avformat_opts, opt_names[i], &opt);
3343 if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3344 av_set_double(oc, opt_names[i], d);
3347 /* reset some options */
3348 file_oformat = NULL;
3349 file_iformat = NULL;
3350 image_format = NULL;
3353 /* prepare dummy protocols for grab */
3354 static void prepare_grab(void)
3356 int has_video, has_audio, i, j;
3357 AVFormatContext *oc;
3358 AVFormatContext *ic;
3359 AVFormatParameters vp1, *vp = &vp1;
3360 AVFormatParameters ap1, *ap = &ap1;
3362 /* see if audio/video inputs are needed */
3365 memset(ap, 0, sizeof(*ap));
3366 memset(vp, 0, sizeof(*vp));
3367 vp->time_base.num= 1;
3368 for(j=0;j<nb_output_files;j++) {
3369 oc = output_files[j];
3370 for(i=0;i<oc->nb_streams;i++) {
3371 AVCodecContext *enc = oc->streams[i]->codec;
3372 switch(enc->codec_type) {
3373 case CODEC_TYPE_AUDIO:
3374 if (enc->sample_rate > ap->sample_rate)
3375 ap->sample_rate = enc->sample_rate;
3376 if (enc->channels > ap->channels)
3377 ap->channels = enc->channels;
3380 case CODEC_TYPE_VIDEO:
3381 if (enc->width > vp->width)
3382 vp->width = enc->width;
3383 if (enc->height > vp->height)
3384 vp->height = enc->height;
3386 if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3387 vp->time_base = enc->time_base;
3388 vp->width += frame_leftBand + frame_rightBand;
3389 vp->width -= (frame_padleft + frame_padright);
3390 vp->height += frame_topBand + frame_bottomBand;
3391 vp->height -= (frame_padtop + frame_padbottom);
3401 if (has_video == 0 && has_audio == 0) {
3402 fprintf(stderr, "Output file must have at least one audio or video stream\n");
3407 AVInputFormat *fmt1;
3408 fmt1 = av_find_input_format(video_grab_format);
3409 vp->device = video_device;
3410 vp->channel = video_channel;
3411 vp->standard = video_standard;
3412 vp->pix_fmt = frame_pix_fmt;
3413 if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3414 fprintf(stderr, "Could not find video grab device\n");
3417 /* If not enough info to get the stream parameters, we decode the
3418 first frames to get it. */
3419 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3420 fprintf(stderr, "Could not find video grab parameters\n");
3423 /* by now video grab has one stream */
3424 ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3425 ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3426 input_files[nb_input_files] = ic;
3429 dump_format(ic, nb_input_files, "", 0);
3433 if (has_audio && audio_grab_format) {
3434 AVInputFormat *fmt1;
3435 fmt1 = av_find_input_format(audio_grab_format);
3436 ap->device = audio_device;
3437 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3438 fprintf(stderr, "Could not find audio grab device\n");
3441 input_files[nb_input_files] = ic;
3444 dump_format(ic, nb_input_files, "", 0);
3450 /* same option as mencoder */
3451 static void opt_pass(const char *pass_str)
3454 pass = atoi(pass_str);
3455 if (pass != 1 && pass != 2) {
3456 fprintf(stderr, "pass number can be only 1 or 2\n");
3462 #if defined(__MINGW32__) || defined(CONFIG_OS2)
3463 static int64_t getutime(void)
3465 return av_gettime();
3468 static int64_t getutime(void)
3470 struct rusage rusage;
3472 getrusage(RUSAGE_SELF, &rusage);
3473 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3477 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3478 extern int ffm_nopts;
3481 static void show_formats(void)
3483 AVInputFormat *ifmt;
3484 AVOutputFormat *ofmt;
3485 AVImageFormat *image_fmt;
3488 const char **pp, *last_name;
3490 printf("File formats:\n");
3495 const char *name=NULL;
3496 const char *long_name=NULL;
3498 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3499 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3500 strcmp(ofmt->name, last_name)>0){
3502 long_name= ofmt->long_name;
3506 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3507 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3508 strcmp(ifmt->name, last_name)>0){
3510 long_name= ifmt->long_name;
3513 if(name && strcmp(ifmt->name, name)==0)
3525 long_name ? long_name:" ");
3529 printf("Image formats (filename extensions, if any, follow):\n");
3530 for(image_fmt = first_image_format; image_fmt != NULL;
3531 image_fmt = image_fmt->next) {
3534 image_fmt->img_read ? "D":" ",
3535 image_fmt->img_write ? "E":" ",
3537 image_fmt->extensions ? image_fmt->extensions:" ");
3541 printf("Codecs:\n");
3547 const char *type_str;
3550 for(p = first_avcodec; p != NULL; p = p->next) {
3551 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3552 strcmp(p->name, last_name)>0){
3554 decode= encode= cap=0;
3556 if(p2 && strcmp(p->name, p2->name)==0){
3557 if(p->decode) decode=1;
3558 if(p->encode) encode=1;
3559 cap |= p->capabilities;
3564 last_name= p2->name;
3567 case CODEC_TYPE_VIDEO:
3570 case CODEC_TYPE_AUDIO:
3573 case CODEC_TYPE_SUBTITLE:
3582 decode ? "D": (/*p2->decoder ? "d":*/" "),
3585 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3586 cap & CODEC_CAP_DR1 ? "D":" ",
3587 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3589 /* if(p2->decoder && decode==0)
3590 printf(" use %s for decoding", p2->decoder->name);*/
3595 printf("Supported file protocols:\n");
3596 for(up = first_protocol; up != NULL; up = up->next)
3597 printf(" %s:", up->name);
3600 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3601 printf("Motion estimation methods:\n");
3605 if ((pp - motion_str + 1) == ME_ZERO)
3606 printf("(fastest)");
3607 else if ((pp - motion_str + 1) == ME_FULL)
3608 printf("(slowest)");
3609 else if ((pp - motion_str + 1) == ME_EPZS)
3610 printf("(default)");
3615 "Note, the names of encoders and decoders dont always match, so there are\n"
3616 "several cases where the above table shows encoder only or decoder only entries\n"
3617 "even though both encoding and decoding are supported for example, the h263\n"
3618 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3623 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3626 const char *p = str;
3633 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3640 static void opt_inter_matrix(const char *arg)
3642 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3643 parse_matrix_coeffs(inter_matrix, arg);
3646 static void opt_intra_matrix(const char *arg)
3648 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3649 parse_matrix_coeffs(intra_matrix, arg);
3652 static void opt_target(const char *arg)
3655 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3657 if(!strncmp(arg, "pal-", 4)) {
3660 } else if(!strncmp(arg, "ntsc-", 5)) {
3663 } else if(!strncmp(arg, "film-", 5)) {
3668 /* Calculate FR via float to avoid int overflow */
3669 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3672 } else if((fr == 29970) || (fr == 23976)) {
3675 /* Try to determine PAL/NTSC by peeking in the input files */
3676 if(nb_input_files) {
3678 for(j = 0; j < nb_input_files; j++) {
3679 for(i = 0; i < input_files[j]->nb_streams; i++) {
3680 AVCodecContext *c = input_files[j]->streams[i]->codec;
3681 if(c->codec_type != CODEC_TYPE_VIDEO)
3683 fr = c->time_base.den * 1000 / c->time_base.num;
3687 } else if((fr == 29970) || (fr == 23976)) {
3697 if(verbose && norm >= 0)
3698 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3702 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3703 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3704 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3708 if(!strcmp(arg, "vcd")) {
3710 opt_video_codec("mpeg1video");
3711 opt_audio_codec("mp2");
3714 opt_frame_size(norm ? "352x240" : "352x288");
3715 opt_frame_rate(frame_rates[norm]);
3716 opt_default("gop", norm ? "18" : "15");
3718 opt_default("b", "1150000");
3719 opt_default("maxrate", "1150000");
3720 opt_default("minrate", "1150000");
3721 video_rc_buffer_size = 40*1024*8;
3723 audio_bit_rate = 224000;
3724 audio_sample_rate = 44100;
3726 mux_packet_size= 2324;
3727 mux_rate= 2352 * 75 * 8;
3729 /* We have to offset the PTS, so that it is consistent with the SCR.
3730 SCR starts at 36000, but the first two packs contain only padding
3731 and the first pack from the other stream, respectively, may also have
3732 been written before.
3733 So the real data starts at SCR 36000+3*1200. */
3734 mux_preload= (36000+3*1200) / 90000.0; //0.44
3735 } else if(!strcmp(arg, "svcd")) {
3737 opt_video_codec("mpeg2video");
3738 opt_audio_codec("mp2");
3741 opt_frame_size(norm ? "480x480" : "480x576");
3742 opt_frame_rate(frame_rates[norm]);
3743 opt_default("gop", norm ? "18" : "15");
3745 opt_default("b", "2040000");
3746 opt_default("maxrate", "2516000");
3747 opt_default("minrate", "0"); //1145000;
3748 video_rc_buffer_size = 224*1024*8;
3749 opt_default("flags", "+SCAN_OFFSET");
3752 audio_bit_rate = 224000;
3753 audio_sample_rate = 44100;
3755 mux_packet_size= 2324;
3757 } else if(!strcmp(arg, "dvd")) {
3759 opt_video_codec("mpeg2video");
3760 opt_audio_codec("ac3");
3763 opt_frame_size(norm ? "720x480" : "720x576");
3764 opt_frame_rate(frame_rates[norm]);
3765 opt_default("gop", norm ? "18" : "15");
3767 opt_default("b", "6000000");
3768 opt_default("maxrate", "9000000");
3769 opt_default("minrate", "0"); //1500000;
3770 video_rc_buffer_size = 224*1024*8;
3772 mux_packet_size= 2048; // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3773 mux_rate = 10080000; // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3775 audio_bit_rate = 448000;
3776 audio_sample_rate = 48000;
3778 } else if(!strncmp(arg, "dv", 2)) {
3782 opt_frame_size(norm ? "720x480" : "720x576");
3783 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3784 (norm ? "yuv411p" : "yuv420p"));
3785 opt_frame_rate(frame_rates[norm]);
3787 audio_sample_rate = 48000;
3791 fprintf(stderr, "Unknown target: %s\n", arg);
3796 static void opt_video_bsf(const char *arg)
3798 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3799 AVBitStreamFilterContext **bsfp;
3802 fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3806 bsfp= &video_bitstream_filters;
3808 bsfp= &(*bsfp)->next;
3813 //FIXME avoid audio - video code duplication
3814 static void opt_audio_bsf(const char *arg)
3816 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3817 AVBitStreamFilterContext **bsfp;
3820 fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3824 bsfp= &audio_bitstream_filters;
3826 bsfp= &(*bsfp)->next;
3831 static void show_version(void)
3833 /* TODO: add function interface to avutil and avformat */
3834 fprintf(stderr, "ffmpeg " FFMPEG_VERSION "\n"
3838 LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3842 static int opt_default(const char *opt, const char *arg){
3843 AVOption *o= av_set_string(avctx_opts, opt, arg);
3845 o = av_set_string(avformat_opts, opt, arg);
3849 // av_log(NULL, AV_LOG_ERROR, "%s:%s: %f 0x%0X\n", opt, arg, av_get_double(avctx_opts, opt, NULL), (int)av_get_int(avctx_opts, opt, NULL));
3851 //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3852 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3853 opt_names[opt_name_count++]= o->name;
3855 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3856 /* disable generate of real time pts in ffm (need to be supressed anyway) */
3857 if(avctx_opts->flags & CODEC_FLAG_BITEXACT)
3861 if(avctx_opts->debug)
3862 av_log_set_level(AV_LOG_DEBUG);
3866 const OptionDef options[] = {
3868 { "L", 0, {(void*)show_license}, "show license" },
3869 { "h", 0, {(void*)show_help}, "show help" },
3870 { "version", 0, {(void*)show_version}, "show version" },
3871 { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3872 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3873 { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3874 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3875 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3876 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3877 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3878 { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3879 { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
3880 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3881 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3882 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3883 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3884 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3885 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3886 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3887 { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3888 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3889 "add timings for benchmarking" },
3890 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3891 "dump each input packet" },
3892 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3893 "when dumping packets, also dump the payload" },
3894 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3895 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3896 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "number of times to loop output in formats that support looping (0 loops forever)", "" },
3897 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3898 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3899 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3900 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3901 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3902 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3903 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3904 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3905 { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3908 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3909 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3910 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3911 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3912 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3913 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3914 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3915 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3916 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3917 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3918 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3919 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3920 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3921 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3922 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3923 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3924 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3925 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3926 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3927 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
3928 { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
3929 { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
3930 { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
3931 { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
3932 { "mblmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmin}, "min macroblock quantiser scale (VBR)", "q" },
3933 { "mblmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmax}, "max macroblock quantiser scale (VBR)", "q" },
3934 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
3935 { "qsquish", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qsquish}, "how to keep quantiser between qmin and qmax (0 = clip, 1 = use differentiable function)", "squish" },
3936 { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
3937 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3938 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3939 { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffer size (in kByte)", "size" },
3940 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3941 { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3943 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
3944 { "mb_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_threshold}, "macroblock threshold", "" },
3945 { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
3946 { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
3947 { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
3948 { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
3949 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3950 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3951 "use same video quality as source (implies VBR)" },
3952 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3953 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3954 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3955 "deinterlace pictures" },
3956 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3957 { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
3958 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3959 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3960 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3961 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3962 { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
3963 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3964 { "mepc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&me_penalty_compensation}, "motion estimation bitrate penalty compensation", "factor (1.0 = 256)" },
3965 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3966 { "skip_threshold", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_threshold}, "frame skip threshold", "threshold" },
3967 { "skip_factor", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_factor}, "frame skip factor", "factor" },
3968 { "skip_exp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_exp}, "frame skip exponent", "exponent" },
3969 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3970 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3973 { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
3974 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3975 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3976 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3977 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3978 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3979 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3980 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3981 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3982 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3984 /* subtitle options */
3985 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3986 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3987 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3990 { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
3991 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3992 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3993 { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
3995 /* G.2 grab options */
3996 { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
3997 { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
4000 { "muxrate", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_rate}, "set mux rate", "rate" },
4001 { "packetsize", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_packet_size}, "set packet size", "size" },
4002 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4003 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4005 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
4006 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
4008 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4012 static void show_banner(void)
4014 fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2004 Fabrice Bellard\n");
4015 fprintf(stderr, " configuration: " FFMPEG_CONFIGURATION "\n");
4016 fprintf(stderr, " libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
4017 fprintf(stderr, " libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
4018 fprintf(stderr, " libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
4019 fprintf(stderr, " built on " __DATE__ " " __TIME__);
4021 fprintf(stderr, ", gcc: " __VERSION__ "\n");
4023 fprintf(stderr, ", using a non-gcc compiler\n");
4027 static void show_license(void)
4032 "This program is free software; you can redistribute it and/or modify\n"
4033 "it under the terms of the GNU General Public License as published by\n"
4034 "the Free Software Foundation; either version 2 of the License, or\n"
4035 "(at your option) any later version.\n"
4037 "This program is distributed in the hope that it will be useful,\n"
4038 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4039 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
4040 "GNU General Public License for more details.\n"
4042 "You should have received a copy of the GNU General Public License\n"
4043 "along with this program; if not, write to the Free Software\n"
4044 "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
4048 "This library is free software; you can redistribute it and/or\n"
4049 "modify it under the terms of the GNU Lesser General Public\n"
4050 "License as published by the Free Software Foundation; either\n"
4051 "version 2 of the License, or (at your option) any later version.\n"
4053 "This library is distributed in the hope that it will be useful,\n"
4054 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4055 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
4056 "Lesser General Public License for more details.\n"
4058 "You should have received a copy of the GNU Lesser General Public\n"
4059 "License along with this library; if not, write to the Free Software\n"
4060 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
4066 static void show_help(void)
4069 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
4070 "Hyper fast Audio and Video encoder\n");
4072 show_help_options(options, "Main options:\n",
4073 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
4074 show_help_options(options, "\nVideo options:\n",
4075 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4077 show_help_options(options, "\nAdvanced Video options:\n",
4078 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4079 OPT_VIDEO | OPT_EXPERT);
4080 show_help_options(options, "\nAudio options:\n",
4081 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4083 show_help_options(options, "\nAdvanced Audio options:\n",
4084 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4085 OPT_AUDIO | OPT_EXPERT);
4086 show_help_options(options, "\nSubtitle options:\n",
4087 OPT_SUBTITLE | OPT_GRAB,
4089 show_help_options(options, "\nAudio/Video grab options:\n",
4092 show_help_options(options, "\nAdvanced options:\n",
4093 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4095 av_opt_show(avctx_opts, NULL);
4096 av_opt_show(avformat_opts, NULL);
4101 void parse_arg_file(const char *filename)
4103 opt_output_file(filename);
4106 int main(int argc, char **argv)
4113 avctx_opts= avcodec_alloc_context();
4114 avformat_opts = av_alloc_format_context();
4122 parse_options(argc, argv, options);
4124 /* file converter / grab */
4125 if (nb_output_files <= 0) {
4126 fprintf(stderr, "Must supply at least one output file\n");
4130 if (nb_input_files == 0) {
4136 av_encode(output_files, nb_output_files, input_files, nb_input_files,
4137 stream_maps, nb_stream_maps);
4138 ti = getutime() - ti;
4140 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4144 for(i=0;i<nb_output_files;i++) {
4145 /* maybe av_close_output_file ??? */
4146 AVFormatContext *s = output_files[i];
4148 if (!(s->oformat->flags & AVFMT_NOFILE))
4150 for(j=0;j<s->nb_streams;j++)
4151 av_free(s->streams[j]);
4154 for(i=0;i<nb_input_files;i++)
4155 av_close_input_file(input_files[i]);
4160 av_free(intra_matrix);
4162 av_free(inter_matrix);
4164 #ifdef POWERPC_PERFORMANCE_REPORT
4165 extern void powerpc_display_perf_report(void);
4166 powerpc_display_perf_report();
4167 #endif /* POWERPC_PERFORMANCE_REPORT */
4170 if (received_sigterm) {
4172 "Received signal %d: terminating.\n",
4173 (int) received_sigterm);
4177 exit(0); /* not all OS-es handle main() return value */