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 int video_bit_rate_tolerance = 4000*1000;
109 static float video_qscale = 0;
110 static int video_qmin = 2;
111 static int video_qmax = 31;
112 static int video_lmin = 2*FF_QP2LAMBDA;
113 static int video_lmax = 31*FF_QP2LAMBDA;
114 static int video_mb_lmin = 2*FF_QP2LAMBDA;
115 static int video_mb_lmax = 31*FF_QP2LAMBDA;
116 static int video_qdiff = 3;
117 static float video_qsquish = 0.0;
118 static uint16_t *intra_matrix = NULL;
119 static uint16_t *inter_matrix = NULL;
120 #if 0 //experimental, (can be removed)
121 static float video_rc_qsquish=1.0;
122 static float video_rc_qmod_amp=0;
123 static int video_rc_qmod_freq=0;
125 static char *video_rc_override_string=NULL;
126 static char *video_rc_eq="tex^qComp";
127 static int video_rc_buffer_size=0;
128 static float video_rc_buffer_aggressivity=1.0;
129 static float video_rc_initial_cplx=0;
130 static int me_method = ME_EPZS;
131 static int video_disable = 0;
132 static int video_discard = 0;
133 static int video_codec_id = CODEC_ID_NONE;
134 static int video_codec_tag = 0;
135 static int same_quality = 0;
136 static int b_frames = 0;
137 static int do_deinterlace = 0;
138 static int workaround_bugs = FF_BUG_AUTODETECT;
139 static int packet_size = 0;
140 static int error_rate = 0;
141 static int strict = 0;
142 static int top_field_first = -1;
143 static int sc_threshold = 0;
144 static int me_threshold = 0;
145 static int mb_threshold = 0;
146 static int intra_dc_precision = 8;
147 static int me_penalty_compensation= 256;
148 static int frame_skip_threshold= 0;
149 static int frame_skip_factor= 0;
150 static int frame_skip_exp= 0;
151 static int loop_input = 0;
152 static int loop_output = AVFMT_NOOUTPUTLOOP;
153 static int qp_hist = 0;
155 static int intra_only = 0;
156 static int audio_sample_rate = 44100;
157 static int audio_bit_rate = 64000;
158 #define QSCALE_NONE -99999
159 static float audio_qscale = QSCALE_NONE;
160 static int audio_disable = 0;
161 static int audio_channels = 1;
162 static int audio_codec_id = CODEC_ID_NONE;
163 static int audio_codec_tag = 0;
164 static char *audio_language = NULL;
166 static int subtitle_codec_id = CODEC_ID_NONE;
167 static char *subtitle_language = NULL;
169 static int mux_rate= 0;
170 static int mux_packet_size= 0;
171 static float mux_preload= 0.5;
172 static float mux_max_delay= 0.7;
174 static int64_t recording_time = 0;
175 static int64_t start_time = 0;
176 static int64_t rec_timestamp = 0;
177 static int64_t input_ts_offset = 0;
178 static int file_overwrite = 0;
179 static char *str_title = NULL;
180 static char *str_author = NULL;
181 static char *str_copyright = NULL;
182 static char *str_comment = NULL;
183 static char *str_album = NULL;
184 static int do_benchmark = 0;
185 static int do_hex_dump = 0;
186 static int do_pkt_dump = 0;
187 static int do_psnr = 0;
188 static int do_vstats = 0;
189 static int do_pass = 0;
190 static char *pass_logfilename = NULL;
191 static int audio_stream_copy = 0;
192 static int video_stream_copy = 0;
193 static int subtitle_stream_copy = 0;
194 static int video_sync_method= 1;
195 static int audio_sync_method= 0;
196 static int copy_ts= 0;
197 static int opt_shortest = 0; //
198 static int video_global_header = 0;
200 static int rate_emu = 0;
203 static const char *video_grab_format = "bktr";
205 #ifdef CONFIG_VIDEO4LINUX2
206 static const char *video_grab_format = "video4linux2";
208 static const char *video_grab_format = "video4linux";
211 static char *video_device = NULL;
212 static char *grab_device = NULL;
213 static int video_channel = 0;
214 static char *video_standard = "ntsc";
216 static const char *audio_grab_format = "audio_device";
217 static char *audio_device = NULL;
218 static int audio_volume = 256;
220 static int using_stdin = 0;
221 static int using_vhook = 0;
222 static int verbose = 1;
223 static int thread_count= 1;
224 static int q_pressed = 0;
225 static int64_t video_size = 0;
226 static int64_t audio_size = 0;
227 static int64_t extra_size = 0;
228 static int nb_frames_dup = 0;
229 static int nb_frames_drop = 0;
230 static int input_sync;
231 static int limit_filesize = 0; //
233 static int pgmyuv_compatibility_hack=0;
234 static int dts_delta_threshold = 10;
236 static int sws_flags = SWS_BICUBIC;
238 const char **opt_names=NULL;
239 int opt_name_count=0;
240 AVCodecContext *avctx_opts;
241 AVFormatContext *avformat_opts;
243 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
244 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
245 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
247 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
249 struct AVInputStream;
251 typedef struct AVOutputStream {
252 int file_index; /* file index */
253 int index; /* stream index in the output file */
254 int source_index; /* AVInputStream index */
255 AVStream *st; /* stream in the output file */
256 int encoding_needed; /* true if encoding needed for this stream */
258 /* input pts and corresponding output pts
260 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
261 struct AVInputStream *sync_ist; /* input stream to sync against */
262 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
265 AVFrame pict_tmp; /* temporary image for resampling */
266 struct SwsContext *img_resample_ctx; /* for image resampling */
270 int topBand; /* cropping area sizes */
274 int padtop; /* padding area sizes */
281 ReSampleContext *resample; /* for audio resampling */
282 FifoBuffer fifo; /* for compression: one audio fifo per codec */
286 typedef struct AVInputStream {
290 int discard; /* true if stream data should be discarded */
291 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
292 int64_t sample_index; /* current sample */
294 int64_t start; /* time when read started */
295 unsigned long frame; /* current frame */
296 int64_t next_pts; /* synthetic pts for cases where pkt.pts
298 int64_t pts; /* current pts */
299 int is_start; /* is 1 at the start and after a discontinuity */
302 typedef struct AVInputFile {
303 int eof_reached; /* true if eof reached */
304 int ist_index; /* index of first stream in ist_table */
305 int buffer_size; /* current total buffer size */
306 int buffer_size_max; /* buffer size at which we consider we can stop
308 int nb_streams; /* nb streams we are aware of */
313 /* init terminal so that we can grab keys */
314 static struct termios oldtty;
316 static void term_exit(void)
318 tcsetattr (0, TCSANOW, &oldtty);
321 static volatile sig_atomic_t received_sigterm = 0;
324 sigterm_handler(int sig)
326 received_sigterm = sig;
330 static void term_init(void)
337 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
338 |INLCR|IGNCR|ICRNL|IXON);
339 tty.c_oflag |= OPOST;
340 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
341 tty.c_cflag &= ~(CSIZE|PARENB);
346 tcsetattr (0, TCSANOW, &tty);
348 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
349 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
350 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
352 register a function to be called at normal program termination
355 #ifdef CONFIG_BEOS_NETSERVER
356 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
360 /* read a key without blocking */
361 static int read_key(void)
365 #ifndef CONFIG_BEOS_NETSERVER
373 n = select(1, &rfds, NULL, NULL, &tv);
385 static int decode_interrupt_cb(void)
387 return q_pressed || (q_pressed = read_key() == 'q');
392 static volatile int received_sigterm = 0;
394 /* no interactive support */
395 static void term_exit(void)
399 static void term_init(void)
403 static int read_key(void)
410 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
415 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
418 /* copy stream format */
419 s->nb_streams = ic->nb_streams;
420 for(i=0;i<ic->nb_streams;i++) {
423 // FIXME: a more elegant solution is needed
424 st = av_mallocz(sizeof(AVStream));
425 memcpy(st, ic->streams[i], sizeof(AVStream));
426 st->codec = avcodec_alloc_context();
427 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
431 av_close_input_file(ic);
436 get_sync_ipts(const AVOutputStream *ost)
438 const AVInputStream *ist = ost->sync_ist;
439 return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
442 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
444 AVPacket new_pkt= *pkt;
445 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
446 &new_pkt.data, &new_pkt.size,
447 pkt->data, pkt->size,
448 pkt->flags & PKT_FLAG_KEY);
451 new_pkt.destruct= av_destruct_packet;
458 av_interleaved_write_frame(s, pkt);
461 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
463 static void do_audio_out(AVFormatContext *s,
466 unsigned char *buf, int size)
469 static uint8_t *audio_buf = NULL;
470 static uint8_t *audio_out = NULL;
471 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
473 int size_out, frame_bytes, ret;
474 AVCodecContext *enc= ost->st->codec;
476 /* SC: dynamic allocation of buffers */
478 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
480 audio_out = av_malloc(audio_out_size);
481 if (!audio_buf || !audio_out)
482 return; /* Should signal an error ! */
484 if(audio_sync_method){
485 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
486 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2);
487 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
488 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
490 //FIXME resample delay
491 if(fabs(delta) > 50){
494 byte_delta= FFMAX(byte_delta, -size);
498 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
503 static uint8_t *input_tmp= NULL;
504 input_tmp= av_realloc(input_tmp, byte_delta + size);
506 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
509 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
511 memset(input_tmp, 0, byte_delta);
512 memcpy(input_tmp + byte_delta, buf, size);
516 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
518 }else if(audio_sync_method>1){
519 int comp= clip(delta, -audio_sync_method, audio_sync_method);
520 assert(ost->audio_resample);
522 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
523 // 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));
524 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
528 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
529 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2); //FIXME wrong
531 if (ost->audio_resample) {
533 size_out = audio_resample(ost->resample,
534 (short *)buftmp, (short *)buf,
535 size / (ist->st->codec->channels * 2));
536 size_out = size_out * enc->channels * 2;
542 /* now encode as many frames as possible */
543 if (enc->frame_size > 1) {
544 /* output resampled raw samples */
545 fifo_write(&ost->fifo, buftmp, size_out,
548 frame_bytes = enc->frame_size * 2 * enc->channels;
550 while (fifo_read(&ost->fifo, audio_buf, frame_bytes,
551 &ost->fifo.rptr) == 0) {
553 av_init_packet(&pkt);
555 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
558 pkt.stream_index= ost->index;
561 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
562 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
563 pkt.flags |= PKT_FLAG_KEY;
564 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
566 ost->sync_opts += enc->frame_size;
570 av_init_packet(&pkt);
572 ost->sync_opts += size_out / (2 * enc->channels);
574 /* output a pcm frame */
575 /* XXX: change encoding codec API to avoid this ? */
576 switch(enc->codec->id) {
577 case CODEC_ID_PCM_S32LE:
578 case CODEC_ID_PCM_S32BE:
579 case CODEC_ID_PCM_U32LE:
580 case CODEC_ID_PCM_U32BE:
581 size_out = size_out << 1;
583 case CODEC_ID_PCM_S24LE:
584 case CODEC_ID_PCM_S24BE:
585 case CODEC_ID_PCM_U24LE:
586 case CODEC_ID_PCM_U24BE:
587 case CODEC_ID_PCM_S24DAUD:
588 size_out = size_out / 2 * 3;
590 case CODEC_ID_PCM_S16LE:
591 case CODEC_ID_PCM_S16BE:
592 case CODEC_ID_PCM_U16LE:
593 case CODEC_ID_PCM_U16BE:
596 size_out = size_out >> 1;
599 ret = avcodec_encode_audio(enc, audio_out, size_out,
602 pkt.stream_index= ost->index;
605 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
606 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
607 pkt.flags |= PKT_FLAG_KEY;
608 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
612 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
616 AVPicture picture_tmp;
619 dec = ist->st->codec;
621 /* deinterlace : must be done before any resize */
622 if (do_deinterlace || using_vhook) {
625 /* create temporary picture */
626 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
627 buf = av_malloc(size);
631 picture2 = &picture_tmp;
632 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
635 if(avpicture_deinterlace(picture2, picture,
636 dec->pix_fmt, dec->width, dec->height) < 0) {
637 /* if error, do not deinterlace */
643 img_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
649 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
651 if (picture != picture2)
652 *picture = *picture2;
656 /* we begin to correct av delay at this threshold */
657 #define AV_DELAY_MAX 0.100
659 static void do_subtitle_out(AVFormatContext *s,
665 static uint8_t *subtitle_out = NULL;
666 int subtitle_out_max_size = 65536;
667 int subtitle_out_size, nb, i;
671 if (pts == AV_NOPTS_VALUE) {
672 fprintf(stderr, "Subtitle packets must have a pts\n");
676 enc = ost->st->codec;
679 subtitle_out = av_malloc(subtitle_out_max_size);
682 /* Note: DVB subtitle need one packet to draw them and one other
683 packet to clear them */
684 /* XXX: signal it in the codec context ? */
685 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
690 for(i = 0; i < nb; i++) {
691 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
692 subtitle_out_max_size, sub);
694 av_init_packet(&pkt);
695 pkt.stream_index = ost->index;
696 pkt.data = subtitle_out;
697 pkt.size = subtitle_out_size;
698 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);
699 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
700 /* XXX: the pts correction is handled here. Maybe handling
701 it in the codec would be better */
703 pkt.pts += 90 * sub->start_display_time;
705 pkt.pts += 90 * sub->end_display_time;
707 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
711 static int bit_buffer_size= 1024*256;
712 static uint8_t *bit_buffer= NULL;
714 static void do_video_out(AVFormatContext *s,
720 int nb_frames, i, ret;
721 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
722 AVFrame picture_crop_temp, picture_pad_temp;
723 uint8_t *buf = NULL, *buf1 = NULL;
724 AVCodecContext *enc, *dec;
726 avcodec_get_frame_defaults(&picture_crop_temp);
727 avcodec_get_frame_defaults(&picture_pad_temp);
729 enc = ost->st->codec;
730 dec = ist->st->codec;
732 /* by default, we output a single frame */
737 if(video_sync_method){
739 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
740 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
743 else if (vdelta > 1.1)
744 nb_frames = lrintf(vdelta);
745 //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);
749 fprintf(stderr, "*** drop!\n");
750 }else if (nb_frames > 1) {
751 nb_frames_dup += nb_frames;
753 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
756 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
758 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
762 if (ost->video_crop) {
763 if (img_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
764 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
767 formatted_picture = &picture_crop_temp;
769 formatted_picture = in_picture;
772 final_picture = formatted_picture;
773 padding_src = formatted_picture;
774 resampling_dst = &ost->pict_tmp;
775 if (ost->video_pad) {
776 final_picture = &ost->pict_tmp;
777 if (ost->video_resample) {
778 if (img_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
779 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
782 resampling_dst = &picture_pad_temp;
786 if (ost->video_resample) {
788 final_picture = &ost->pict_tmp;
789 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
790 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
793 if (ost->video_pad) {
794 img_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
795 enc->height, enc->width, enc->pix_fmt,
796 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
799 /* duplicates frame if needed */
800 for(i=0;i<nb_frames;i++) {
802 av_init_packet(&pkt);
803 pkt.stream_index= ost->index;
805 if (s->oformat->flags & AVFMT_RAWPICTURE) {
806 /* raw pictures are written as AVPicture structure to
807 avoid any copies. We support temorarily the older
809 AVFrame* old_frame = enc->coded_frame;
810 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
811 pkt.data= (uint8_t *)final_picture;
812 pkt.size= sizeof(AVPicture);
813 if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
814 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
815 if(dec->coded_frame && dec->coded_frame->key_frame)
816 pkt.flags |= PKT_FLAG_KEY;
818 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
819 enc->coded_frame = old_frame;
823 big_picture= *final_picture;
824 /* better than nothing: use input picture interlaced
826 big_picture.interlaced_frame = in_picture->interlaced_frame;
827 if(avctx_opts->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
828 if(top_field_first == -1)
829 big_picture.top_field_first = in_picture->top_field_first;
831 big_picture.top_field_first = top_field_first;
834 /* handles sameq here. This is not correct because it may
835 not be a global option */
837 big_picture.quality = ist->st->quality;
839 big_picture.quality = ost->st->quality;
841 big_picture.pict_type = 0;
842 // big_picture.pts = AV_NOPTS_VALUE;
843 big_picture.pts= ost->sync_opts;
844 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
845 //av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
846 ret = avcodec_encode_video(enc,
847 bit_buffer, bit_buffer_size,
849 //enc->frame_number = enc->real_pict_num;
851 pkt.data= bit_buffer;
853 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
854 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
855 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n",
856 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
857 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
859 if(enc->coded_frame && enc->coded_frame->key_frame)
860 pkt.flags |= PKT_FLAG_KEY;
861 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
863 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
864 // enc->frame_number-1, enc->real_pict_num, ret,
866 /* if two pass, output log */
867 if (ost->logfile && enc->stats_out) {
868 fprintf(ost->logfile, "%s", enc->stats_out);
880 static double psnr(double d){
881 if(d==0) return INFINITY;
882 return -10.0*log(d)/log(10.0);
885 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
888 static FILE *fvstats=NULL;
895 double ti1, bitrate, avg_bitrate;
899 today = localtime(&today2);
900 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
903 fvstats = fopen(filename,"w");
911 enc = ost->st->codec;
912 if (enc->codec_type == CODEC_TYPE_VIDEO) {
913 frame_number = ost->frame_number;
914 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
915 if (enc->flags&CODEC_FLAG_PSNR)
916 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
918 fprintf(fvstats,"f_size= %6d ", frame_size);
919 /* compute pts value */
920 ti1 = ost->sync_opts * av_q2d(enc->time_base);
924 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
925 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
926 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
927 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
928 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
932 static void print_report(AVFormatContext **output_files,
933 AVOutputStream **ost_table, int nb_ostreams,
938 AVFormatContext *oc, *os;
941 int frame_number, vid, i;
942 double bitrate, ti1, pts;
943 static int64_t last_time = -1;
944 static int qp_histogram[52];
946 if (!is_last_report) {
948 /* display the report every 0.5 seconds */
949 cur_time = av_gettime();
950 if (last_time == -1) {
951 last_time = cur_time;
954 if ((cur_time - last_time) < 500000)
956 last_time = cur_time;
960 oc = output_files[0];
962 total_size = url_ftell(&oc->pb);
967 for(i=0;i<nb_ostreams;i++) {
969 os = output_files[ost->file_index];
970 enc = ost->st->codec;
971 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
972 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
973 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
975 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
976 frame_number = ost->frame_number;
977 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%3.1f ",
978 frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
980 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
981 if(qp_hist && enc->coded_frame){
983 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
984 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
987 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
989 if (enc->flags&CODEC_FLAG_PSNR){
991 double error, error_sum=0;
992 double scale, scale_sum=0;
993 char type[3]= {'Y','U','V'};
994 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
997 error= enc->error[j];
998 scale= enc->width*enc->height*255.0*255.0*frame_number;
1000 error= enc->coded_frame->error[j];
1001 scale= enc->width*enc->height*255.0*255.0;
1006 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1008 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1012 /* compute min output value */
1013 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1014 if ((pts < ti1) && (pts > 0))
1020 if (verbose || is_last_report) {
1021 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1023 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1024 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1025 (double)total_size / 1024, ti1, bitrate);
1028 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1029 nb_frames_dup, nb_frames_drop);
1032 fprintf(stderr, "%s \r", buf);
1037 if (is_last_report && verbose >= 0){
1038 int64_t raw= audio_size + video_size + extra_size;
1039 fprintf(stderr, "\n");
1040 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1044 100.0*(total_size - raw)/raw
1049 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1050 static int output_packet(AVInputStream *ist, int ist_index,
1051 AVOutputStream **ost_table, int nb_ostreams,
1052 const AVPacket *pkt)
1054 AVFormatContext *os;
1055 AVOutputStream *ost;
1059 int data_size, got_picture;
1061 void *buffer_to_free;
1062 static unsigned int samples_size= 0;
1063 static short *samples= NULL;
1064 AVSubtitle subtitle, *subtitle_to_free;
1068 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1069 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1070 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1072 // assert(ist->pts == ist->next_pts);
1086 /* decode the packet if needed */
1087 data_buf = NULL; /* fail safe */
1089 subtitle_to_free = NULL;
1090 if (ist->decoding_needed) {
1091 switch(ist->st->codec->codec_type) {
1092 case CODEC_TYPE_AUDIO:{
1094 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1095 /* XXX: could avoid copy if PCM 16 bits with same
1096 endianness as CPU */
1097 ret = avcodec_decode_audio(ist->st->codec, samples, &data_size,
1103 /* Some bug in mpeg audio decoder gives */
1104 /* data_size < 0, it seems they are overflows */
1105 if (data_size <= 0) {
1106 /* no audio frame */
1109 data_buf = (uint8_t *)samples;
1110 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1111 (ist->st->codec->sample_rate * ist->st->codec->channels);
1113 case CODEC_TYPE_VIDEO:
1114 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1115 /* XXX: allocate picture correctly */
1116 avcodec_get_frame_defaults(&picture);
1118 ret = avcodec_decode_video(ist->st->codec,
1119 &picture, &got_picture, ptr, len);
1120 ist->st->quality= picture.quality;
1124 /* no picture yet */
1125 goto discard_packet;
1127 if (ist->st->codec->time_base.num != 0) {
1128 ist->next_pts += ((int64_t)AV_TIME_BASE *
1129 ist->st->codec->time_base.num) /
1130 ist->st->codec->time_base.den;
1134 case CODEC_TYPE_SUBTITLE:
1135 ret = avcodec_decode_subtitle(ist->st->codec,
1136 &subtitle, &got_subtitle, ptr, len);
1139 if (!got_subtitle) {
1140 goto discard_packet;
1142 subtitle_to_free = &subtitle;
1149 switch(ist->st->codec->codec_type) {
1150 case CODEC_TYPE_AUDIO:
1151 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1152 (ist->st->codec->sample_rate * ist->st->codec->channels);
1154 case CODEC_TYPE_VIDEO:
1155 if (ist->st->codec->time_base.num != 0) {
1156 ist->next_pts += ((int64_t)AV_TIME_BASE *
1157 ist->st->codec->time_base.num) /
1158 ist->st->codec->time_base.den;
1168 buffer_to_free = NULL;
1169 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1170 pre_process_video_frame(ist, (AVPicture *)&picture,
1174 // preprocess audio (volume)
1175 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1176 if (audio_volume != 256) {
1179 for(i=0;i<(data_size / sizeof(short));i++) {
1180 int v = ((*volp) * audio_volume + 128) >> 8;
1181 if (v < -32768) v = -32768;
1182 if (v > 32767) v = 32767;
1188 /* frame rate emulation */
1189 if (ist->st->codec->rate_emu) {
1190 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1191 int64_t now = av_gettime() - ist->start;
1199 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1200 is the one of the next displayed one */
1201 /* XXX: add mpeg4 too ? */
1202 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1203 if (ist->st->codec->pict_type != B_TYPE) {
1205 tmp = ist->last_ip_pts;
1206 ist->last_ip_pts = ist->frac_pts.val;
1207 ist->frac_pts.val = tmp;
1211 /* if output time reached then transcode raw format,
1212 encode packets and output them */
1213 if (start_time == 0 || ist->pts >= start_time)
1214 for(i=0;i<nb_ostreams;i++) {
1218 if (ost->source_index == ist_index) {
1219 os = output_files[ost->file_index];
1222 printf("%d: got pts=%0.3f %0.3f\n", i,
1223 (double)pkt->pts / AV_TIME_BASE,
1224 ((double)ist->pts / AV_TIME_BASE) -
1225 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1227 /* set the input output pts pairs */
1228 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1230 if (ost->encoding_needed) {
1231 switch(ost->st->codec->codec_type) {
1232 case CODEC_TYPE_AUDIO:
1233 do_audio_out(os, ost, ist, data_buf, data_size);
1235 case CODEC_TYPE_VIDEO:
1236 do_video_out(os, ost, ist, &picture, &frame_size);
1237 video_size += frame_size;
1238 if (do_vstats && frame_size)
1239 do_video_stats(os, ost, frame_size);
1241 case CODEC_TYPE_SUBTITLE:
1242 do_subtitle_out(os, ost, ist, &subtitle,
1249 AVFrame avframe; //FIXME/XXX remove this
1251 av_init_packet(&opkt);
1253 /* no reencoding needed : output the packet directly */
1254 /* force the input stream PTS */
1256 avcodec_get_frame_defaults(&avframe);
1257 ost->st->codec->coded_frame= &avframe;
1258 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1260 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1261 audio_size += data_size;
1262 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1263 video_size += data_size;
1267 opkt.stream_index= ost->index;
1268 if(pkt->pts != AV_NOPTS_VALUE)
1269 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);
1271 opkt.pts= AV_NOPTS_VALUE;
1275 if (pkt->dts == AV_NOPTS_VALUE)
1276 dts = ist->next_pts;
1278 dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1279 opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
1281 opkt.flags= pkt->flags;
1283 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1284 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1285 opkt.destruct= av_destruct_packet;
1287 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1288 ost->st->codec->frame_number++;
1289 ost->frame_number++;
1290 av_free_packet(&opkt);
1294 av_free(buffer_to_free);
1295 /* XXX: allocate the subtitles in the codec ? */
1296 if (subtitle_to_free) {
1297 if (subtitle_to_free->rects != NULL) {
1298 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1299 av_free(subtitle_to_free->rects[i].bitmap);
1300 av_free(subtitle_to_free->rects[i].rgba_palette);
1302 av_freep(&subtitle_to_free->rects);
1304 subtitle_to_free->num_rects = 0;
1305 subtitle_to_free = NULL;
1312 for(i=0;i<nb_ostreams;i++) {
1314 if (ost->source_index == ist_index) {
1315 AVCodecContext *enc= ost->st->codec;
1316 os = output_files[ost->file_index];
1318 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1320 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1323 if (ost->encoding_needed) {
1327 av_init_packet(&pkt);
1328 pkt.stream_index= ost->index;
1330 switch(ost->st->codec->codec_type) {
1331 case CODEC_TYPE_AUDIO:
1332 fifo_bytes = fifo_size(&ost->fifo, NULL);
1334 /* encode any samples remaining in fifo */
1335 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1336 int fs_tmp = enc->frame_size;
1337 enc->frame_size = fifo_bytes / (2 * enc->channels);
1338 if(fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes,
1339 &ost->fifo.rptr) == 0) {
1340 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1342 enc->frame_size = fs_tmp;
1345 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1348 pkt.flags |= PKT_FLAG_KEY;
1350 case CODEC_TYPE_VIDEO:
1351 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1353 if(enc->coded_frame && enc->coded_frame->key_frame)
1354 pkt.flags |= PKT_FLAG_KEY;
1355 if (ost->logfile && enc->stats_out) {
1356 fprintf(ost->logfile, "%s", enc->stats_out);
1365 pkt.data= bit_buffer;
1367 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1368 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1369 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1383 * The following code is the main loop of the file converter
1385 static int av_encode(AVFormatContext **output_files,
1386 int nb_output_files,
1387 AVFormatContext **input_files,
1389 AVStreamMap *stream_maps, int nb_stream_maps)
1391 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1392 AVFormatContext *is, *os;
1393 AVCodecContext *codec, *icodec;
1394 AVOutputStream *ost, **ost_table = NULL;
1395 AVInputStream *ist, **ist_table = NULL;
1396 AVInputFile *file_table;
1397 AVFormatContext *stream_no_data;
1400 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1404 /* input stream init */
1406 for(i=0;i<nb_input_files;i++) {
1407 is = input_files[i];
1408 file_table[i].ist_index = j;
1409 file_table[i].nb_streams = is->nb_streams;
1410 j += is->nb_streams;
1414 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1418 for(i=0;i<nb_istreams;i++) {
1419 ist = av_mallocz(sizeof(AVInputStream));
1425 for(i=0;i<nb_input_files;i++) {
1426 is = input_files[i];
1427 for(k=0;k<is->nb_streams;k++) {
1428 ist = ist_table[j++];
1429 ist->st = is->streams[k];
1430 ist->file_index = i;
1432 ist->discard = 1; /* the stream is discarded by default
1435 if (ist->st->codec->rate_emu) {
1436 ist->start = av_gettime();
1442 /* output stream init */
1444 for(i=0;i<nb_output_files;i++) {
1445 os = output_files[i];
1446 nb_ostreams += os->nb_streams;
1448 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1449 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1453 /* Sanity check the mapping args -- do the input files & streams exist? */
1454 for(i=0;i<nb_stream_maps;i++) {
1455 int fi = stream_maps[i].file_index;
1456 int si = stream_maps[i].stream_index;
1458 if (fi < 0 || fi > nb_input_files - 1 ||
1459 si < 0 || si > file_table[fi].nb_streams - 1) {
1460 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1463 fi = stream_maps[i].sync_file_index;
1464 si = stream_maps[i].sync_stream_index;
1465 if (fi < 0 || fi > nb_input_files - 1 ||
1466 si < 0 || si > file_table[fi].nb_streams - 1) {
1467 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1472 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1475 for(i=0;i<nb_ostreams;i++) {
1476 ost = av_mallocz(sizeof(AVOutputStream));
1483 for(k=0;k<nb_output_files;k++) {
1484 os = output_files[k];
1485 for(i=0;i<os->nb_streams;i++) {
1487 ost = ost_table[n++];
1488 ost->file_index = k;
1490 ost->st = os->streams[i];
1491 if (nb_stream_maps > 0) {
1492 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1493 stream_maps[n-1].stream_index;
1495 /* Sanity check that the stream types match */
1496 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1497 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1498 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1499 ost->file_index, ost->index);
1504 /* get corresponding input stream index : we select the first one with the right type */
1506 for(j=0;j<nb_istreams;j++) {
1509 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1510 ost->source_index = j;
1517 /* try again and reuse existing stream */
1518 for(j=0;j<nb_istreams;j++) {
1520 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1521 ost->source_index = j;
1526 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1527 ost->file_index, ost->index);
1532 ist = ist_table[ost->source_index];
1534 ost->sync_ist = (nb_stream_maps > 0) ?
1535 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1536 stream_maps[n-1].sync_stream_index] : ist;
1540 /* for each output stream, we compute the right encoding parameters */
1541 for(i=0;i<nb_ostreams;i++) {
1543 ist = ist_table[ost->source_index];
1545 codec = ost->st->codec;
1546 icodec = ist->st->codec;
1548 if (ost->st->stream_copy) {
1549 /* if stream_copy is selected, no need to decode or encode */
1550 codec->codec_id = icodec->codec_id;
1551 codec->codec_type = icodec->codec_type;
1552 if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1553 codec->bit_rate = icodec->bit_rate;
1554 codec->extradata= icodec->extradata;
1555 codec->extradata_size= icodec->extradata_size;
1556 codec->time_base = icodec->time_base;
1557 switch(codec->codec_type) {
1558 case CODEC_TYPE_AUDIO:
1559 codec->sample_rate = icodec->sample_rate;
1560 codec->channels = icodec->channels;
1561 codec->frame_size = icodec->frame_size;
1562 codec->block_align= icodec->block_align;
1564 case CODEC_TYPE_VIDEO:
1565 codec->pix_fmt = icodec->pix_fmt;
1566 codec->width = icodec->width;
1567 codec->height = icodec->height;
1568 codec->has_b_frames = icodec->has_b_frames;
1570 case CODEC_TYPE_SUBTITLE:
1576 switch(codec->codec_type) {
1577 case CODEC_TYPE_AUDIO:
1578 if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1581 if (codec->channels == icodec->channels &&
1582 codec->sample_rate == icodec->sample_rate) {
1583 ost->audio_resample = 0;
1585 if (codec->channels != icodec->channels &&
1586 (icodec->codec_id == CODEC_ID_AC3 ||
1587 icodec->codec_id == CODEC_ID_DTS)) {
1588 /* Special case for 5:1 AC3 and DTS input */
1589 /* and mono or stereo output */
1590 /* Request specific number of channels */
1591 icodec->channels = codec->channels;
1592 if (codec->sample_rate == icodec->sample_rate)
1593 ost->audio_resample = 0;
1595 ost->audio_resample = 1;
1598 ost->audio_resample = 1;
1601 if(audio_sync_method>1)
1602 ost->audio_resample = 1;
1604 if(ost->audio_resample){
1605 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1606 codec->sample_rate, icodec->sample_rate);
1608 printf("Can't resample. Aborting.\n");
1612 ist->decoding_needed = 1;
1613 ost->encoding_needed = 1;
1615 case CODEC_TYPE_VIDEO:
1616 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1617 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1618 ost->video_resample = ((codec->width != icodec->width -
1619 (frame_leftBand + frame_rightBand) +
1620 (frame_padleft + frame_padright)) ||
1621 (codec->height != icodec->height -
1622 (frame_topBand + frame_bottomBand) +
1623 (frame_padtop + frame_padbottom)) ||
1624 (codec->pix_fmt != icodec->pix_fmt));
1625 if (ost->video_crop) {
1626 ost->topBand = frame_topBand;
1627 ost->leftBand = frame_leftBand;
1629 if (ost->video_pad) {
1630 ost->padtop = frame_padtop;
1631 ost->padleft = frame_padleft;
1632 ost->padbottom = frame_padbottom;
1633 ost->padright = frame_padright;
1634 if (!ost->video_resample) {
1635 avcodec_get_frame_defaults(&ost->pict_tmp);
1636 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1637 codec->width, codec->height ) )
1641 if (ost->video_resample) {
1642 avcodec_get_frame_defaults(&ost->pict_tmp);
1643 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1644 codec->width, codec->height ) )
1647 ost->img_resample_ctx = sws_getContext(
1648 icodec->width - (frame_leftBand + frame_rightBand),
1649 icodec->height - (frame_topBand + frame_bottomBand),
1651 codec->width - (frame_padleft + frame_padright),
1652 codec->height - (frame_padtop + frame_padbottom),
1654 sws_flags, NULL, NULL, NULL);
1655 if (ost->img_resample_ctx == NULL) {
1656 fprintf(stderr, "Cannot get resampling context\n");
1659 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1661 ost->encoding_needed = 1;
1662 ist->decoding_needed = 1;
1664 case CODEC_TYPE_SUBTITLE:
1665 ost->encoding_needed = 1;
1666 ist->decoding_needed = 1;
1673 if (ost->encoding_needed &&
1674 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1675 char logfilename[1024];
1680 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1682 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1683 if (codec->flags & CODEC_FLAG_PASS1) {
1684 f = fopen(logfilename, "w");
1686 perror(logfilename);
1691 /* read the log file */
1692 f = fopen(logfilename, "r");
1694 perror(logfilename);
1697 fseek(f, 0, SEEK_END);
1699 fseek(f, 0, SEEK_SET);
1700 logbuffer = av_malloc(size + 1);
1702 fprintf(stderr, "Could not allocate log buffer\n");
1705 size = fread(logbuffer, 1, size, f);
1707 logbuffer[size] = '\0';
1708 codec->stats_in = logbuffer;
1712 if(codec->codec_type == CODEC_TYPE_VIDEO){
1713 int size= codec->width * codec->height;
1714 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1719 bit_buffer = av_malloc(bit_buffer_size);
1723 /* dump the file output parameters - cannot be done before in case
1725 for(i=0;i<nb_output_files;i++) {
1726 dump_format(output_files[i], i, output_files[i]->filename, 1);
1729 /* dump the stream mapping */
1731 fprintf(stderr, "Stream mapping:\n");
1732 for(i=0;i<nb_ostreams;i++) {
1734 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1735 ist_table[ost->source_index]->file_index,
1736 ist_table[ost->source_index]->index,
1739 if (ost->sync_ist != ist_table[ost->source_index])
1740 fprintf(stderr, " [sync #%d.%d]",
1741 ost->sync_ist->file_index,
1742 ost->sync_ist->index);
1743 fprintf(stderr, "\n");
1747 /* open each encoder */
1748 for(i=0;i<nb_ostreams;i++) {
1750 if (ost->encoding_needed) {
1752 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1754 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1755 ost->file_index, ost->index);
1758 if (avcodec_open(ost->st->codec, codec) < 0) {
1759 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1760 ost->file_index, ost->index);
1763 extra_size += ost->st->codec->extradata_size;
1767 /* open each decoder */
1768 for(i=0;i<nb_istreams;i++) {
1770 if (ist->decoding_needed) {
1772 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1774 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1775 ist->st->codec->codec_id, ist->file_index, ist->index);
1778 if (avcodec_open(ist->st->codec, codec) < 0) {
1779 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1780 ist->file_index, ist->index);
1783 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1784 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1789 for(i=0;i<nb_istreams;i++) {
1791 is = input_files[ist->file_index];
1793 ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1794 if(ist->st->start_time == AV_NOPTS_VALUE)
1796 if(input_files_ts_offset[ist->file_index])
1797 ist->next_pts= AV_NOPTS_VALUE;
1801 /* compute buffer size max (should use a complete heuristic) */
1802 for(i=0;i<nb_input_files;i++) {
1803 file_table[i].buffer_size_max = 2048;
1806 /* set meta data information from input file if required */
1807 for (i=0;i<nb_meta_data_maps;i++) {
1808 AVFormatContext *out_file;
1809 AVFormatContext *in_file;
1811 int out_file_index = meta_data_maps[i].out_file;
1812 int in_file_index = meta_data_maps[i].in_file;
1813 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1814 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1818 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1819 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1824 out_file = output_files[out_file_index];
1825 in_file = input_files[in_file_index];
1827 strcpy(out_file->title, in_file->title);
1828 strcpy(out_file->author, in_file->author);
1829 strcpy(out_file->copyright, in_file->copyright);
1830 strcpy(out_file->comment, in_file->comment);
1831 strcpy(out_file->album, in_file->album);
1832 out_file->year = in_file->year;
1833 out_file->track = in_file->track;
1834 strcpy(out_file->genre, in_file->genre);
1837 /* open files and write file headers */
1838 for(i=0;i<nb_output_files;i++) {
1839 os = output_files[i];
1840 if (av_write_header(os) < 0) {
1841 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1848 if ( !using_stdin && verbose >= 0) {
1849 fprintf(stderr, "Press [q] to stop encoding\n");
1850 url_set_interrupt_cb(decode_interrupt_cb);
1858 for(; received_sigterm == 0;) {
1859 int file_index, ist_index;
1867 /* if 'q' pressed, exits */
1871 /* read_key() returns 0 on EOF */
1877 /* select the stream that we must read now by looking at the
1878 smallest output pts */
1880 for(i=0;i<nb_ostreams;i++) {
1883 os = output_files[ost->file_index];
1884 ist = ist_table[ost->source_index];
1885 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1886 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1888 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1889 ipts = (double)ist->pts;
1890 if (!file_table[ist->file_index].eof_reached){
1891 if(ipts < ipts_min) {
1893 if(input_sync ) file_index = ist->file_index;
1895 if(opts < opts_min) {
1897 if(!input_sync) file_index = ist->file_index;
1900 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1905 /* if none, if is finished */
1906 if (file_index < 0) {
1910 /* finish if recording time exhausted */
1911 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1914 /* finish if limit size exhausted */
1915 if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1918 /* read a frame from it and output it in the fifo */
1919 is = input_files[file_index];
1920 if (av_read_frame(is, &pkt) < 0) {
1921 file_table[file_index].eof_reached = 1;
1922 if (opt_shortest) break; else continue; //
1926 stream_no_data = is;
1931 av_pkt_dump(stdout, &pkt, do_hex_dump);
1933 /* the following test is needed in case new streams appear
1934 dynamically in stream : we ignore them */
1935 if (pkt.stream_index >= file_table[file_index].nb_streams)
1936 goto discard_packet;
1937 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1938 ist = ist_table[ist_index];
1940 goto discard_packet;
1942 // 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);
1943 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1944 int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1945 if(ABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1946 input_files_ts_offset[ist->file_index]-= delta;
1948 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1949 for(i=0; i<file_table[file_index].nb_streams; i++){
1950 int index= file_table[file_index].ist_index + i;
1951 ist_table[index]->next_pts += delta;
1952 ist_table[index]->is_start=1;
1957 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1958 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1961 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1962 ist->file_index, ist->index);
1964 av_free_packet(&pkt);
1969 av_free_packet(&pkt);
1971 /* dump report by using the output first video and audio streams */
1972 print_report(output_files, ost_table, nb_ostreams, 0);
1975 /* at the end of stream, we must flush the decoder buffers */
1976 for(i=0;i<nb_istreams;i++) {
1978 if (ist->decoding_needed) {
1979 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1985 /* write the trailer if needed and close file */
1986 for(i=0;i<nb_output_files;i++) {
1987 os = output_files[i];
1988 av_write_trailer(os);
1991 /* dump report by using the first video and audio streams */
1992 print_report(output_files, ost_table, nb_ostreams, 1);
1994 /* close each encoder */
1995 for(i=0;i<nb_ostreams;i++) {
1997 if (ost->encoding_needed) {
1998 av_freep(&ost->st->codec->stats_in);
1999 avcodec_close(ost->st->codec);
2003 /* close each decoder */
2004 for(i=0;i<nb_istreams;i++) {
2006 if (ist->decoding_needed) {
2007 avcodec_close(ist->st->codec);
2015 av_freep(&bit_buffer);
2016 av_free(file_table);
2019 for(i=0;i<nb_istreams;i++) {
2026 for(i=0;i<nb_ostreams;i++) {
2030 fclose(ost->logfile);
2031 ost->logfile = NULL;
2033 fifo_free(&ost->fifo); /* works even if fifo is not
2034 initialized but set to zero */
2035 av_free(ost->pict_tmp.data[0]);
2036 if (ost->video_resample)
2037 sws_freeContext(ost->img_resample_ctx);
2038 if (ost->audio_resample)
2039 audio_resample_close(ost->resample);
2052 int file_read(const char *filename)
2055 unsigned char buffer[1024];
2058 if (url_open(&h, filename, O_RDONLY) < 0) {
2059 printf("could not open '%s'\n", filename);
2063 len = url_read(h, buffer, sizeof(buffer));
2066 for(i=0;i<len;i++) putchar(buffer[i]);
2073 static void opt_image_format(const char *arg)
2077 for(f = first_image_format; f != NULL; f = f->next) {
2078 if (!strcmp(arg, f->name))
2082 fprintf(stderr, "Unknown image format: '%s'\n", arg);
2088 static void opt_format(const char *arg)
2090 /* compatibility stuff for pgmyuv */
2091 if (!strcmp(arg, "pgmyuv")) {
2092 pgmyuv_compatibility_hack=1;
2093 // opt_image_format(arg);
2097 file_iformat = av_find_input_format(arg);
2098 file_oformat = guess_format(arg, NULL, NULL);
2099 if (!file_iformat && !file_oformat) {
2100 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2105 static void opt_video_bitrate_tolerance(const char *arg)
2107 video_bit_rate_tolerance = atoi(arg) * 1000;
2110 static void opt_video_buffer_size(const char *arg)
2112 video_rc_buffer_size = atoi(arg) * 8*1024;
2115 static void opt_video_rc_eq(char *arg)
2120 static void opt_video_rc_override_string(char *arg)
2122 video_rc_override_string = arg;
2126 static void opt_workaround_bugs(const char *arg)
2128 workaround_bugs = atoi(arg);
2131 static void opt_me_threshold(const char *arg)
2133 me_threshold = atoi(arg);
2136 static void opt_mb_threshold(const char *arg)
2138 mb_threshold = atoi(arg);
2141 static void opt_verbose(const char *arg)
2143 verbose = atoi(arg);
2144 av_log_set_level(atoi(arg));
2147 static void opt_frame_rate(const char *arg)
2149 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2150 fprintf(stderr, "Incorrect frame rate\n");
2155 static void opt_frame_crop_top(const char *arg)
2157 frame_topBand = atoi(arg);
2158 if (frame_topBand < 0) {
2159 fprintf(stderr, "Incorrect top crop size\n");
2162 if ((frame_topBand % 2) != 0) {
2163 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2166 if ((frame_topBand) >= frame_height){
2167 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2170 frame_height -= frame_topBand;
2173 static void opt_frame_crop_bottom(const char *arg)
2175 frame_bottomBand = atoi(arg);
2176 if (frame_bottomBand < 0) {
2177 fprintf(stderr, "Incorrect bottom crop size\n");
2180 if ((frame_bottomBand % 2) != 0) {
2181 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2184 if ((frame_bottomBand) >= frame_height){
2185 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2188 frame_height -= frame_bottomBand;
2191 static void opt_frame_crop_left(const char *arg)
2193 frame_leftBand = atoi(arg);
2194 if (frame_leftBand < 0) {
2195 fprintf(stderr, "Incorrect left crop size\n");
2198 if ((frame_leftBand % 2) != 0) {
2199 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2202 if ((frame_leftBand) >= frame_width){
2203 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2206 frame_width -= frame_leftBand;
2209 static void opt_frame_crop_right(const char *arg)
2211 frame_rightBand = atoi(arg);
2212 if (frame_rightBand < 0) {
2213 fprintf(stderr, "Incorrect right crop size\n");
2216 if ((frame_rightBand % 2) != 0) {
2217 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2220 if ((frame_rightBand) >= frame_width){
2221 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2224 frame_width -= frame_rightBand;
2227 static void opt_frame_size(const char *arg)
2229 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2230 fprintf(stderr, "Incorrect frame size\n");
2233 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2234 fprintf(stderr, "Frame size must be a multiple of 2\n");
2240 #define SCALEBITS 10
2241 #define ONE_HALF (1 << (SCALEBITS - 1))
2242 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2244 #define RGB_TO_Y(r, g, b) \
2245 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2246 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2248 #define RGB_TO_U(r1, g1, b1, shift)\
2249 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2250 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2252 #define RGB_TO_V(r1, g1, b1, shift)\
2253 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2254 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2256 static void opt_pad_color(const char *arg) {
2257 /* Input is expected to be six hex digits similar to
2258 how colors are expressed in html tags (but without the #) */
2259 int rgb = strtol(arg, NULL, 16);
2263 g = ((rgb >> 8) & 255);
2266 padcolor[0] = RGB_TO_Y(r,g,b);
2267 padcolor[1] = RGB_TO_U(r,g,b,0);
2268 padcolor[2] = RGB_TO_V(r,g,b,0);
2271 static void opt_frame_pad_top(const char *arg)
2273 frame_padtop = atoi(arg);
2274 if (frame_padtop < 0) {
2275 fprintf(stderr, "Incorrect top pad size\n");
2278 if ((frame_padtop % 2) != 0) {
2279 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2284 static void opt_frame_pad_bottom(const char *arg)
2286 frame_padbottom = atoi(arg);
2287 if (frame_padbottom < 0) {
2288 fprintf(stderr, "Incorrect bottom pad size\n");
2291 if ((frame_padbottom % 2) != 0) {
2292 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2298 static void opt_frame_pad_left(const char *arg)
2300 frame_padleft = atoi(arg);
2301 if (frame_padleft < 0) {
2302 fprintf(stderr, "Incorrect left pad size\n");
2305 if ((frame_padleft % 2) != 0) {
2306 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2312 static void opt_frame_pad_right(const char *arg)
2314 frame_padright = atoi(arg);
2315 if (frame_padright < 0) {
2316 fprintf(stderr, "Incorrect right pad size\n");
2319 if ((frame_padright % 2) != 0) {
2320 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2326 static void opt_frame_pix_fmt(const char *arg)
2328 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2331 static void opt_frame_aspect_ratio(const char *arg)
2337 p = strchr(arg, ':');
2339 x = strtol(arg, (char **)&arg, 10);
2341 y = strtol(arg+1, (char **)&arg, 10);
2343 ar = (double)x / (double)y;
2345 ar = strtod(arg, (char **)&arg);
2348 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2351 frame_aspect_ratio = ar;
2354 static void opt_b_frames(const char *arg)
2356 b_frames = atoi(arg);
2357 if (b_frames > FF_MAX_B_FRAMES) {
2358 fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2360 } else if (b_frames < 1) {
2361 fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2366 static void opt_qscale(const char *arg)
2368 video_qscale = atof(arg);
2369 if (video_qscale <= 0 ||
2370 video_qscale > 255) {
2371 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2376 static void opt_qsquish(const char *arg)
2378 video_qsquish = atof(arg);
2379 if (video_qsquish < 0.0 ||
2380 video_qsquish > 99.0) {
2381 fprintf(stderr, "qsquish must be >= 0.0 and <= 99.0\n");
2386 static void opt_lmax(const char *arg)
2388 video_lmax = atof(arg)*FF_QP2LAMBDA;
2391 static void opt_lmin(const char *arg)
2393 video_lmin = atof(arg)*FF_QP2LAMBDA;
2396 static void opt_qmin(const char *arg)
2398 video_qmin = atoi(arg);
2399 if (video_qmin < 1 ||
2401 fprintf(stderr, "qmin must be >= 1 and <= 51\n");
2406 static void opt_qmax(const char *arg)
2408 video_qmax = atoi(arg);
2409 if (video_qmax < 1 ||
2411 fprintf(stderr, "qmax must be >= 1 and <= 51\n");
2416 static void opt_mb_lmin(const char *arg)
2418 video_mb_lmin = atof(arg)*FF_QP2LAMBDA;
2419 if (video_mb_lmin < 1 ||
2420 video_mb_lmin > FF_LAMBDA_MAX) {
2421 fprintf(stderr, "mblmin must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2426 static void opt_mb_lmax(const char *arg)
2428 video_mb_lmax = atof(arg)*FF_QP2LAMBDA;
2429 if (video_mb_lmax < 1 ||
2430 video_mb_lmax > FF_LAMBDA_MAX) {
2431 fprintf(stderr, "mblmax must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2436 static void opt_qdiff(const char *arg)
2438 video_qdiff = atoi(arg);
2439 if (video_qdiff < 0 ||
2441 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2446 static void opt_rc_initial_cplx(const char *arg)
2448 video_rc_initial_cplx = atof(arg);
2451 static void opt_packet_size(const char *arg)
2453 packet_size= atoi(arg);
2456 static void opt_error_rate(const char *arg)
2458 error_rate= atoi(arg);
2461 static void opt_strict(const char *arg)
2466 static void opt_top_field_first(const char *arg)
2468 top_field_first= atoi(arg);
2471 static void opt_sc_threshold(const char *arg)
2473 sc_threshold= atoi(arg);
2476 static void opt_thread_count(const char *arg)
2478 thread_count= atoi(arg);
2479 #if !defined(HAVE_THREADS)
2481 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2485 static void opt_audio_bitrate(const char *arg)
2487 audio_bit_rate = atoi(arg) * 1000;
2490 static void opt_audio_rate(const char *arg)
2492 audio_sample_rate = atoi(arg);
2495 static void opt_audio_channels(const char *arg)
2497 audio_channels = atoi(arg);
2500 static void opt_video_device(const char *arg)
2502 video_device = av_strdup(arg);
2505 static void opt_grab_device(const char *arg)
2507 grab_device = av_strdup(arg);
2510 static void opt_video_channel(const char *arg)
2512 video_channel = strtol(arg, NULL, 0);
2515 static void opt_video_standard(const char *arg)
2517 video_standard = av_strdup(arg);
2520 static void opt_audio_device(const char *arg)
2522 audio_device = av_strdup(arg);
2525 static void opt_codec(int *pstream_copy, int *pcodec_id,
2526 int codec_type, const char *arg)
2530 if (!strcmp(arg, "copy")) {
2535 if (!strcmp(p->name, arg) && p->type == codec_type)
2540 fprintf(stderr, "Unknown codec '%s'\n", arg);
2548 static void opt_audio_codec(const char *arg)
2550 opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2553 static void opt_audio_tag(const char *arg)
2556 audio_codec_tag= strtol(arg, &tail, 0);
2559 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2562 static void opt_video_tag(const char *arg)
2565 video_codec_tag= strtol(arg, &tail, 0);
2568 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2571 static void add_frame_hooker(const char *arg)
2576 char *args = av_strdup(arg);
2580 argv[0] = strtok(args, " ");
2581 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2584 i = frame_hook_add(argc, argv);
2587 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2592 const char *motion_str[] = {
2605 static void opt_motion_estimation(const char *arg)
2611 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2614 if (!strcmp(*p, arg))
2618 me_method = (p - motion_str) + 1;
2621 static void opt_video_codec(const char *arg)
2623 opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2626 static void opt_subtitle_codec(const char *arg)
2628 opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2631 static void opt_map(const char *arg)
2637 m = &stream_maps[nb_stream_maps++];
2639 m->file_index = strtol(arg, (char **)&p, 0);
2643 m->stream_index = strtol(p, (char **)&p, 0);
2646 m->sync_file_index = strtol(p, (char **)&p, 0);
2649 m->sync_stream_index = strtol(p, (char **)&p, 0);
2651 m->sync_file_index = m->file_index;
2652 m->sync_stream_index = m->stream_index;
2656 static void opt_map_meta_data(const char *arg)
2662 m = &meta_data_maps[nb_meta_data_maps++];
2664 m->out_file = strtol(arg, (char **)&p, 0);
2668 m->in_file = strtol(p, (char **)&p, 0);
2671 static void opt_recording_time(const char *arg)
2673 recording_time = parse_date(arg, 1);
2676 static void opt_start_time(const char *arg)
2678 start_time = parse_date(arg, 1);
2681 static void opt_rec_timestamp(const char *arg)
2683 rec_timestamp = parse_date(arg, 0) / 1000000;
2686 static void opt_input_ts_offset(const char *arg)
2688 input_ts_offset = parse_date(arg, 1);
2691 static void opt_input_file(const char *filename)
2693 AVFormatContext *ic;
2694 AVFormatParameters params, *ap = ¶ms;
2695 int err, i, ret, rfps, rfps_base;
2698 if (!strcmp(filename, "-"))
2701 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2702 !strcmp( filename, "/dev/stdin" );
2704 /* get default parameters from command line */
2705 ic = av_alloc_format_context();
2707 memset(ap, 0, sizeof(*ap));
2708 ap->prealloced_context = 1;
2709 ap->sample_rate = audio_sample_rate;
2710 ap->channels = audio_channels;
2711 ap->time_base.den = frame_rate;
2712 ap->time_base.num = frame_rate_base;
2713 ap->width = frame_width + frame_padleft + frame_padright;
2714 ap->height = frame_height + frame_padtop + frame_padbottom;
2715 ap->image_format = image_format;
2716 ap->pix_fmt = frame_pix_fmt;
2717 ap->device = grab_device;
2718 ap->channel = video_channel;
2719 ap->standard = video_standard;
2720 ap->video_codec_id = video_codec_id;
2721 ap->audio_codec_id = audio_codec_id;
2722 if(pgmyuv_compatibility_hack)
2723 ap->video_codec_id= CODEC_ID_PGMYUV;
2725 for(i=0; i<opt_name_count; i++){
2727 double d= av_get_double(avformat_opts, opt_names[i], &opt);
2728 if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2729 av_set_double(ic, opt_names[i], d);
2731 /* open the input file with generic libav function */
2732 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2734 print_error(filename, err);
2738 ic->loop_input = loop_input;
2740 /* If not enough info to get the stream parameters, we decode the
2741 first frames to get it. (used in mpeg case for example) */
2742 ret = av_find_stream_info(ic);
2743 if (ret < 0 && verbose >= 0) {
2744 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2748 timestamp = start_time;
2749 /* add the stream start time */
2750 if (ic->start_time != AV_NOPTS_VALUE)
2751 timestamp += ic->start_time;
2753 /* if seeking requested, we execute it */
2754 if (start_time != 0) {
2755 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2757 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2758 filename, (double)timestamp / AV_TIME_BASE);
2760 /* reset seek info */
2764 /* update the current parameters so that they match the one of the input stream */
2765 for(i=0;i<ic->nb_streams;i++) {
2767 AVCodecContext *enc = ic->streams[i]->codec;
2768 #if defined(HAVE_THREADS)
2770 avcodec_thread_init(enc, thread_count);
2772 enc->thread_count= thread_count;
2773 switch(enc->codec_type) {
2774 case CODEC_TYPE_AUDIO:
2775 for(j=0; j<opt_name_count; j++){
2777 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2778 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2779 av_set_double(enc, opt_names[j], d);
2781 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2782 audio_channels = enc->channels;
2783 audio_sample_rate = enc->sample_rate;
2785 ic->streams[i]->discard= AVDISCARD_ALL;
2787 case CODEC_TYPE_VIDEO:
2788 for(j=0; j<opt_name_count; j++){
2790 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2791 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2792 av_set_double(enc, opt_names[j], d);
2794 frame_height = enc->height;
2795 frame_width = enc->width;
2796 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2797 frame_pix_fmt = enc->pix_fmt;
2798 rfps = ic->streams[i]->r_frame_rate.num;
2799 rfps_base = ic->streams[i]->r_frame_rate.den;
2800 enc->workaround_bugs = workaround_bugs;
2801 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2803 enc->debug |= FF_DEBUG_MV;
2805 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2808 fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2809 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2811 (float)rfps / rfps_base, rfps, rfps_base);
2813 /* update the current frame rate to match the stream frame rate */
2815 frame_rate_base = rfps_base;
2817 enc->rate_emu = rate_emu;
2819 ic->streams[i]->discard= AVDISCARD_ALL;
2820 else if(video_discard)
2821 ic->streams[i]->discard= video_discard;
2823 case CODEC_TYPE_DATA:
2825 case CODEC_TYPE_SUBTITLE:
2827 case CODEC_TYPE_UNKNOWN:
2834 input_files[nb_input_files] = ic;
2835 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2836 /* dump the file content */
2838 dump_format(ic, nb_input_files, filename, 0);
2841 file_iformat = NULL;
2842 file_oformat = NULL;
2843 image_format = NULL;
2851 static void opt_grab(const char *arg)
2853 file_iformat = av_find_input_format(arg);
2857 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2859 int has_video, has_audio, i, j;
2860 AVFormatContext *ic;
2864 for(j=0;j<nb_input_files;j++) {
2865 ic = input_files[j];
2866 for(i=0;i<ic->nb_streams;i++) {
2867 AVCodecContext *enc = ic->streams[i]->codec;
2868 switch(enc->codec_type) {
2869 case CODEC_TYPE_AUDIO:
2872 case CODEC_TYPE_VIDEO:
2875 case CODEC_TYPE_DATA:
2876 case CODEC_TYPE_UNKNOWN:
2877 case CODEC_TYPE_SUBTITLE:
2884 *has_video_ptr = has_video;
2885 *has_audio_ptr = has_audio;
2888 static void new_video_stream(AVFormatContext *oc)
2891 AVCodecContext *video_enc;
2894 st = av_new_stream(oc, oc->nb_streams);
2896 fprintf(stderr, "Could not alloc stream\n");
2899 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2900 video_bitstream_filters= NULL;
2902 #if defined(HAVE_THREADS)
2904 avcodec_thread_init(st->codec, thread_count);
2907 video_enc = st->codec;
2910 video_enc->codec_tag= video_codec_tag;
2912 if( (video_global_header&1)
2913 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2914 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2915 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2917 if(video_global_header&2){
2918 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2919 avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2922 if (video_stream_copy) {
2923 st->stream_copy = 1;
2924 video_enc->codec_type = CODEC_TYPE_VIDEO;
2930 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2931 if (video_codec_id != CODEC_ID_NONE)
2932 codec_id = video_codec_id;
2934 video_enc->codec_id = codec_id;
2935 codec = avcodec_find_encoder(codec_id);
2937 for(i=0; i<opt_name_count; i++){
2939 double d= av_get_double(avctx_opts, opt_names[i], &opt);
2940 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2941 av_set_double(video_enc, opt_names[i], d);
2944 video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
2945 video_enc->time_base.den = frame_rate;
2946 video_enc->time_base.num = frame_rate_base;
2947 if(codec && codec->supported_framerates){
2948 const AVRational *p= codec->supported_framerates;
2949 AVRational req= (AVRational){frame_rate, frame_rate_base};
2950 const AVRational *best=NULL;
2951 AVRational best_error= (AVRational){INT_MAX, 1};
2952 for(; p->den!=0; p++){
2953 AVRational error= av_sub_q(req, *p);
2954 if(error.num <0) error.num *= -1;
2955 if(av_cmp_q(error, best_error) < 0){
2960 video_enc->time_base.den= best->num;
2961 video_enc->time_base.num= best->den;
2964 video_enc->width = frame_width + frame_padright + frame_padleft;
2965 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2966 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2967 video_enc->pix_fmt = frame_pix_fmt;
2969 if(codec && codec->pix_fmts){
2970 const enum PixelFormat *p= codec->pix_fmts;
2972 if(*p == video_enc->pix_fmt)
2976 video_enc->pix_fmt = codec->pix_fmts[0];
2980 video_enc->gop_size = 0;
2981 if (video_qscale || same_quality) {
2982 video_enc->flags |= CODEC_FLAG_QSCALE;
2983 video_enc->global_quality=
2984 st->quality = FF_QP2LAMBDA * video_qscale;
2988 video_enc->intra_matrix = intra_matrix;
2990 video_enc->inter_matrix = inter_matrix;
2992 video_enc->max_b_frames = b_frames;
2993 video_enc->qmin = video_qmin;
2994 video_enc->qmax = video_qmax;
2995 video_enc->lmin = video_lmin;
2996 video_enc->lmax = video_lmax;
2997 video_enc->rc_qsquish = video_qsquish;
2998 video_enc->mb_lmin = video_mb_lmin;
2999 video_enc->mb_lmax = video_mb_lmax;
3000 video_enc->max_qdiff = video_qdiff;
3001 video_enc->rc_eq = video_rc_eq;
3002 video_enc->workaround_bugs = workaround_bugs;
3003 video_enc->thread_count = thread_count;
3004 p= video_rc_override_string;
3007 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3009 fprintf(stderr, "error parsing rc_override\n");
3012 video_enc->rc_override=
3013 av_realloc(video_enc->rc_override,
3014 sizeof(RcOverride)*(i+1));
3015 video_enc->rc_override[i].start_frame= start;
3016 video_enc->rc_override[i].end_frame = end;
3018 video_enc->rc_override[i].qscale= q;
3019 video_enc->rc_override[i].quality_factor= 1.0;
3022 video_enc->rc_override[i].qscale= 0;
3023 video_enc->rc_override[i].quality_factor= -q/100.0;
3028 video_enc->rc_override_count=i;
3030 video_enc->rc_buffer_size = video_rc_buffer_size;
3031 video_enc->rc_initial_buffer_occupancy = video_rc_buffer_size*3/4;
3032 video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
3033 video_enc->rc_initial_cplx= video_rc_initial_cplx;
3034 video_enc->me_threshold= me_threshold;
3035 video_enc->mb_threshold= mb_threshold;
3036 video_enc->intra_dc_precision= intra_dc_precision - 8;
3037 video_enc->strict_std_compliance = strict;
3038 video_enc->error_rate = error_rate;
3039 video_enc->scenechange_threshold= sc_threshold;
3040 video_enc->me_penalty_compensation= me_penalty_compensation;
3041 video_enc->frame_skip_threshold= frame_skip_threshold;
3042 video_enc->frame_skip_factor= frame_skip_factor;
3043 video_enc->frame_skip_exp= frame_skip_exp;
3046 video_enc->rtp_mode= 1;
3047 video_enc->rtp_payload_size= packet_size;
3051 video_enc->flags|= CODEC_FLAG_PSNR;
3053 video_enc->me_method = me_method;
3058 video_enc->flags |= CODEC_FLAG_PASS1;
3060 video_enc->flags |= CODEC_FLAG_PASS2;
3065 /* reset some key parameters */
3067 video_codec_id = CODEC_ID_NONE;
3068 video_stream_copy = 0;
3071 static void new_audio_stream(AVFormatContext *oc)
3074 AVCodecContext *audio_enc;
3077 st = av_new_stream(oc, oc->nb_streams);
3079 fprintf(stderr, "Could not alloc stream\n");
3083 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3084 audio_bitstream_filters= NULL;
3086 #if defined(HAVE_THREADS)
3088 avcodec_thread_init(st->codec, thread_count);
3091 audio_enc = st->codec;
3092 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3095 audio_enc->codec_tag= audio_codec_tag;
3097 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3098 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3099 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
3101 if (audio_stream_copy) {
3102 st->stream_copy = 1;
3103 audio_enc->channels = audio_channels;
3105 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3107 for(i=0; i<opt_name_count; i++){
3109 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3110 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3111 av_set_double(audio_enc, opt_names[i], d);
3114 if (audio_codec_id != CODEC_ID_NONE)
3115 codec_id = audio_codec_id;
3116 audio_enc->codec_id = codec_id;
3118 audio_enc->bit_rate = audio_bit_rate;
3119 if (audio_qscale > QSCALE_NONE) {
3120 audio_enc->flags |= CODEC_FLAG_QSCALE;
3121 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3123 audio_enc->strict_std_compliance = strict;
3124 audio_enc->thread_count = thread_count;
3125 /* For audio codecs other than AC3 or DTS we limit */
3126 /* the number of coded channels to stereo */
3127 if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3128 && codec_id != CODEC_ID_DTS) {
3129 audio_enc->channels = 2;
3131 audio_enc->channels = audio_channels;
3133 audio_enc->sample_rate = audio_sample_rate;
3134 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3135 if (audio_language) {
3136 pstrcpy(st->language, sizeof(st->language), audio_language);
3137 av_free(audio_language);
3138 audio_language = NULL;
3141 /* reset some key parameters */
3143 audio_codec_id = CODEC_ID_NONE;
3144 audio_stream_copy = 0;
3147 static void opt_new_subtitle_stream(void)
3149 AVFormatContext *oc;
3151 AVCodecContext *subtitle_enc;
3154 if (nb_output_files <= 0) {
3155 fprintf(stderr, "At least one output file must be specified\n");
3158 oc = output_files[nb_output_files - 1];
3160 st = av_new_stream(oc, oc->nb_streams);
3162 fprintf(stderr, "Could not alloc stream\n");
3166 subtitle_enc = st->codec;
3167 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3168 if (subtitle_stream_copy) {
3169 st->stream_copy = 1;
3171 for(i=0; i<opt_name_count; i++){
3173 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3174 if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3175 av_set_double(subtitle_enc, opt_names[i], d);
3177 subtitle_enc->codec_id = subtitle_codec_id;
3180 if (subtitle_language) {
3181 pstrcpy(st->language, sizeof(st->language), subtitle_language);
3182 av_free(subtitle_language);
3183 subtitle_language = NULL;
3186 subtitle_codec_id = CODEC_ID_NONE;
3187 subtitle_stream_copy = 0;
3190 static void opt_new_audio_stream(void)
3192 AVFormatContext *oc;
3193 if (nb_output_files <= 0) {
3194 fprintf(stderr, "At least one output file must be specified\n");
3197 oc = output_files[nb_output_files - 1];
3198 new_audio_stream(oc);
3201 static void opt_new_video_stream(void)
3203 AVFormatContext *oc;
3204 if (nb_output_files <= 0) {
3205 fprintf(stderr, "At least one output file must be specified\n");
3208 oc = output_files[nb_output_files - 1];
3209 new_video_stream(oc);
3212 static void opt_output_file(const char *filename)
3214 AVFormatContext *oc;
3215 int use_video, use_audio, input_has_video, input_has_audio, i;
3216 AVFormatParameters params, *ap = ¶ms;
3218 if (!strcmp(filename, "-"))
3221 oc = av_alloc_format_context();
3223 if (!file_oformat) {
3224 file_oformat = guess_format(NULL, filename, NULL);
3225 if (!file_oformat) {
3226 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3232 oc->oformat = file_oformat;
3233 pstrcpy(oc->filename, sizeof(oc->filename), filename);
3235 if (!strcmp(file_oformat->name, "ffm") &&
3236 strstart(filename, "http:", NULL)) {
3237 /* special case for files sent to ffserver: we get the stream
3238 parameters from ffserver */
3239 if (read_ffserver_streams(oc, filename) < 0) {
3240 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3244 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3245 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3247 /* disable if no corresponding type found and at least one
3249 if (nb_input_files > 0) {
3250 check_audio_video_inputs(&input_has_video, &input_has_audio);
3251 if (!input_has_video)
3253 if (!input_has_audio)
3257 /* manual disable */
3258 if (audio_disable) {
3261 if (video_disable) {
3266 new_video_stream(oc);
3270 new_audio_stream(oc);
3273 if (!oc->nb_streams) {
3274 fprintf(stderr, "No audio or video streams available\n");
3278 oc->timestamp = rec_timestamp;
3281 pstrcpy(oc->title, sizeof(oc->title), str_title);
3283 pstrcpy(oc->author, sizeof(oc->author), str_author);
3285 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3287 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3289 pstrcpy(oc->album, sizeof(oc->album), str_album);
3292 output_files[nb_output_files++] = oc;
3294 /* check filename in case of an image number is expected */
3295 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3296 if (!av_filename_number_test(oc->filename)) {
3297 print_error(oc->filename, AVERROR_NUMEXPECTED);
3302 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3303 /* test if it already exists to avoid loosing precious files */
3304 if (!file_overwrite &&
3305 (strchr(filename, ':') == NULL ||
3306 strstart(filename, "file:", NULL))) {
3307 if (url_exist(filename)) {
3310 if ( !using_stdin ) {
3311 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3314 if (toupper(c) != 'Y') {
3315 fprintf(stderr, "Not overwriting - exiting\n");
3320 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3327 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3328 fprintf(stderr, "Could not open '%s'\n", filename);
3333 memset(ap, 0, sizeof(*ap));
3334 ap->image_format = image_format;
3335 if (av_set_parameters(oc, ap) < 0) {
3336 fprintf(stderr, "%s: Invalid encoding parameters\n",
3341 oc->packet_size= mux_packet_size;
3342 oc->mux_rate= mux_rate;
3343 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3344 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3345 oc->loop_output = loop_output;
3347 for(i=0; i<opt_name_count; i++){
3349 double d = av_get_double(avformat_opts, opt_names[i], &opt);
3350 if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3351 av_set_double(oc, opt_names[i], d);
3354 /* reset some options */
3355 file_oformat = NULL;
3356 file_iformat = NULL;
3357 image_format = NULL;
3360 /* prepare dummy protocols for grab */
3361 static void prepare_grab(void)
3363 int has_video, has_audio, i, j;
3364 AVFormatContext *oc;
3365 AVFormatContext *ic;
3366 AVFormatParameters vp1, *vp = &vp1;
3367 AVFormatParameters ap1, *ap = &ap1;
3369 /* see if audio/video inputs are needed */
3372 memset(ap, 0, sizeof(*ap));
3373 memset(vp, 0, sizeof(*vp));
3374 vp->time_base.num= 1;
3375 for(j=0;j<nb_output_files;j++) {
3376 oc = output_files[j];
3377 for(i=0;i<oc->nb_streams;i++) {
3378 AVCodecContext *enc = oc->streams[i]->codec;
3379 switch(enc->codec_type) {
3380 case CODEC_TYPE_AUDIO:
3381 if (enc->sample_rate > ap->sample_rate)
3382 ap->sample_rate = enc->sample_rate;
3383 if (enc->channels > ap->channels)
3384 ap->channels = enc->channels;
3387 case CODEC_TYPE_VIDEO:
3388 if (enc->width > vp->width)
3389 vp->width = enc->width;
3390 if (enc->height > vp->height)
3391 vp->height = enc->height;
3393 if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3394 vp->time_base = enc->time_base;
3395 vp->width += frame_leftBand + frame_rightBand;
3396 vp->width -= (frame_padleft + frame_padright);
3397 vp->height += frame_topBand + frame_bottomBand;
3398 vp->height -= (frame_padtop + frame_padbottom);
3408 if (has_video == 0 && has_audio == 0) {
3409 fprintf(stderr, "Output file must have at least one audio or video stream\n");
3414 AVInputFormat *fmt1;
3415 fmt1 = av_find_input_format(video_grab_format);
3416 vp->device = video_device;
3417 vp->channel = video_channel;
3418 vp->standard = video_standard;
3419 vp->pix_fmt = frame_pix_fmt;
3420 if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3421 fprintf(stderr, "Could not find video grab device\n");
3424 /* If not enough info to get the stream parameters, we decode the
3425 first frames to get it. */
3426 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3427 fprintf(stderr, "Could not find video grab parameters\n");
3430 /* by now video grab has one stream */
3431 ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3432 ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3433 input_files[nb_input_files] = ic;
3436 dump_format(ic, nb_input_files, "", 0);
3440 if (has_audio && audio_grab_format) {
3441 AVInputFormat *fmt1;
3442 fmt1 = av_find_input_format(audio_grab_format);
3443 ap->device = audio_device;
3444 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3445 fprintf(stderr, "Could not find audio grab device\n");
3448 input_files[nb_input_files] = ic;
3451 dump_format(ic, nb_input_files, "", 0);
3457 /* same option as mencoder */
3458 static void opt_pass(const char *pass_str)
3461 pass = atoi(pass_str);
3462 if (pass != 1 && pass != 2) {
3463 fprintf(stderr, "pass number can be only 1 or 2\n");
3469 #if defined(__MINGW32__) || defined(CONFIG_OS2)
3470 static int64_t getutime(void)
3472 return av_gettime();
3475 static int64_t getutime(void)
3477 struct rusage rusage;
3479 getrusage(RUSAGE_SELF, &rusage);
3480 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3484 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3485 extern int ffm_nopts;
3488 static void show_formats(void)
3490 AVInputFormat *ifmt;
3491 AVOutputFormat *ofmt;
3492 AVImageFormat *image_fmt;
3495 const char **pp, *last_name;
3497 printf("File formats:\n");
3502 const char *name=NULL;
3503 const char *long_name=NULL;
3505 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3506 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3507 strcmp(ofmt->name, last_name)>0){
3509 long_name= ofmt->long_name;
3513 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3514 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3515 strcmp(ifmt->name, last_name)>0){
3517 long_name= ifmt->long_name;
3520 if(name && strcmp(ifmt->name, name)==0)
3532 long_name ? long_name:" ");
3536 printf("Image formats (filename extensions, if any, follow):\n");
3537 for(image_fmt = first_image_format; image_fmt != NULL;
3538 image_fmt = image_fmt->next) {
3541 image_fmt->img_read ? "D":" ",
3542 image_fmt->img_write ? "E":" ",
3544 image_fmt->extensions ? image_fmt->extensions:" ");
3548 printf("Codecs:\n");
3554 const char *type_str;
3557 for(p = first_avcodec; p != NULL; p = p->next) {
3558 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3559 strcmp(p->name, last_name)>0){
3561 decode= encode= cap=0;
3563 if(p2 && strcmp(p->name, p2->name)==0){
3564 if(p->decode) decode=1;
3565 if(p->encode) encode=1;
3566 cap |= p->capabilities;
3571 last_name= p2->name;
3574 case CODEC_TYPE_VIDEO:
3577 case CODEC_TYPE_AUDIO:
3580 case CODEC_TYPE_SUBTITLE:
3589 decode ? "D": (/*p2->decoder ? "d":*/" "),
3592 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3593 cap & CODEC_CAP_DR1 ? "D":" ",
3594 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3596 /* if(p2->decoder && decode==0)
3597 printf(" use %s for decoding", p2->decoder->name);*/
3602 printf("Supported file protocols:\n");
3603 for(up = first_protocol; up != NULL; up = up->next)
3604 printf(" %s:", up->name);
3607 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3608 printf("Motion estimation methods:\n");
3612 if ((pp - motion_str + 1) == ME_ZERO)
3613 printf("(fastest)");
3614 else if ((pp - motion_str + 1) == ME_FULL)
3615 printf("(slowest)");
3616 else if ((pp - motion_str + 1) == ME_EPZS)
3617 printf("(default)");
3622 "Note, the names of encoders and decoders dont always match, so there are\n"
3623 "several cases where the above table shows encoder only or decoder only entries\n"
3624 "even though both encoding and decoding are supported for example, the h263\n"
3625 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3630 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3633 const char *p = str;
3640 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3647 static void opt_inter_matrix(const char *arg)
3649 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3650 parse_matrix_coeffs(inter_matrix, arg);
3653 static void opt_intra_matrix(const char *arg)
3655 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3656 parse_matrix_coeffs(intra_matrix, arg);
3659 static void opt_target(const char *arg)
3662 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3664 if(!strncmp(arg, "pal-", 4)) {
3667 } else if(!strncmp(arg, "ntsc-", 5)) {
3670 } else if(!strncmp(arg, "film-", 5)) {
3675 /* Calculate FR via float to avoid int overflow */
3676 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3679 } else if((fr == 29970) || (fr == 23976)) {
3682 /* Try to determine PAL/NTSC by peeking in the input files */
3683 if(nb_input_files) {
3685 for(j = 0; j < nb_input_files; j++) {
3686 for(i = 0; i < input_files[j]->nb_streams; i++) {
3687 AVCodecContext *c = input_files[j]->streams[i]->codec;
3688 if(c->codec_type != CODEC_TYPE_VIDEO)
3690 fr = c->time_base.den * 1000 / c->time_base.num;
3694 } else if((fr == 29970) || (fr == 23976)) {
3704 if(verbose && norm >= 0)
3705 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3709 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3710 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3711 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3715 if(!strcmp(arg, "vcd")) {
3717 opt_video_codec("mpeg1video");
3718 opt_audio_codec("mp2");
3721 opt_frame_size(norm ? "352x240" : "352x288");
3722 opt_frame_rate(frame_rates[norm]);
3723 opt_default("gop", norm ? "18" : "15");
3725 opt_default("b", "1150000");
3726 opt_default("maxrate", "1150000");
3727 opt_default("minrate", "1150000");
3728 video_rc_buffer_size = 40*1024*8;
3730 audio_bit_rate = 224000;
3731 audio_sample_rate = 44100;
3733 mux_packet_size= 2324;
3734 mux_rate= 2352 * 75 * 8;
3736 /* We have to offset the PTS, so that it is consistent with the SCR.
3737 SCR starts at 36000, but the first two packs contain only padding
3738 and the first pack from the other stream, respectively, may also have
3739 been written before.
3740 So the real data starts at SCR 36000+3*1200. */
3741 mux_preload= (36000+3*1200) / 90000.0; //0.44
3742 } else if(!strcmp(arg, "svcd")) {
3744 opt_video_codec("mpeg2video");
3745 opt_audio_codec("mp2");
3748 opt_frame_size(norm ? "480x480" : "480x576");
3749 opt_frame_rate(frame_rates[norm]);
3750 opt_default("gop", norm ? "18" : "15");
3752 opt_default("b", "2040000");
3753 opt_default("maxrate", "2516000");
3754 opt_default("minrate", "0"); //1145000;
3755 video_rc_buffer_size = 224*1024*8;
3756 opt_default("flags", "+SCAN_OFFSET");
3759 audio_bit_rate = 224000;
3760 audio_sample_rate = 44100;
3762 mux_packet_size= 2324;
3764 } else if(!strcmp(arg, "dvd")) {
3766 opt_video_codec("mpeg2video");
3767 opt_audio_codec("ac3");
3770 opt_frame_size(norm ? "720x480" : "720x576");
3771 opt_frame_rate(frame_rates[norm]);
3772 opt_default("gop", norm ? "18" : "15");
3774 opt_default("b", "6000000");
3775 opt_default("maxrate", "9000000");
3776 opt_default("minrate", "0"); //1500000;
3777 video_rc_buffer_size = 224*1024*8;
3779 mux_packet_size= 2048; // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3780 mux_rate = 10080000; // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3782 audio_bit_rate = 448000;
3783 audio_sample_rate = 48000;
3785 } else if(!strncmp(arg, "dv", 2)) {
3789 opt_frame_size(norm ? "720x480" : "720x576");
3790 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3791 (norm ? "yuv411p" : "yuv420p"));
3792 opt_frame_rate(frame_rates[norm]);
3794 audio_sample_rate = 48000;
3798 fprintf(stderr, "Unknown target: %s\n", arg);
3803 static void opt_video_bsf(const char *arg)
3805 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3806 AVBitStreamFilterContext **bsfp;
3809 fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3813 bsfp= &video_bitstream_filters;
3815 bsfp= &(*bsfp)->next;
3820 //FIXME avoid audio - video code duplication
3821 static void opt_audio_bsf(const char *arg)
3823 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3824 AVBitStreamFilterContext **bsfp;
3827 fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3831 bsfp= &audio_bitstream_filters;
3833 bsfp= &(*bsfp)->next;
3838 static void show_version(void)
3840 /* TODO: add function interface to avutil and avformat */
3841 fprintf(stderr, "ffmpeg " FFMPEG_VERSION "\n"
3845 LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3849 static int opt_default(const char *opt, const char *arg){
3850 AVOption *o= av_set_string(avctx_opts, opt, arg);
3852 o = av_set_string(avformat_opts, opt, arg);
3856 // 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));
3858 //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3859 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3860 opt_names[opt_name_count++]= o->name;
3862 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3863 /* disable generate of real time pts in ffm (need to be supressed anyway) */
3864 if(avctx_opts->flags & CODEC_FLAG_BITEXACT)
3868 if(avctx_opts->debug)
3869 av_log_set_level(AV_LOG_DEBUG);
3873 const OptionDef options[] = {
3875 { "L", 0, {(void*)show_license}, "show license" },
3876 { "h", 0, {(void*)show_help}, "show help" },
3877 { "version", 0, {(void*)show_version}, "show version" },
3878 { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3879 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3880 { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3881 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3882 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3883 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3884 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3885 { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3886 { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
3887 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3888 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3889 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3890 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3891 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3892 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3893 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3894 { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3895 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3896 "add timings for benchmarking" },
3897 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3898 "dump each input packet" },
3899 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3900 "when dumping packets, also dump the payload" },
3901 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3902 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3903 { "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)", "" },
3904 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3905 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3906 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3907 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3908 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3909 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3910 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3911 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3912 { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3915 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3916 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3917 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3918 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3919 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3920 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3921 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3922 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3923 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3924 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3925 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3926 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3927 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3928 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3929 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3930 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3931 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3932 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3933 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3934 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
3935 { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
3936 { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
3937 { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
3938 { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
3939 { "mblmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmin}, "min macroblock quantiser scale (VBR)", "q" },
3940 { "mblmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmax}, "max macroblock quantiser scale (VBR)", "q" },
3941 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
3942 { "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" },
3943 { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
3944 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3945 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3946 { "bt", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
3947 { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffer size (in kByte)", "size" },
3948 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3949 { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3951 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
3952 { "mb_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_threshold}, "macroblock threshold", "" },
3953 { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
3954 { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
3955 { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
3956 { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
3957 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3958 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3959 "use same video quality as source (implies VBR)" },
3960 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3961 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3962 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3963 "deinterlace pictures" },
3964 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3965 { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
3966 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3967 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3968 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3969 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3970 { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
3971 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3972 { "mepc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&me_penalty_compensation}, "motion estimation bitrate penalty compensation", "factor (1.0 = 256)" },
3973 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3974 { "skip_threshold", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_threshold}, "frame skip threshold", "threshold" },
3975 { "skip_factor", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_factor}, "frame skip factor", "factor" },
3976 { "skip_exp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_exp}, "frame skip exponent", "exponent" },
3977 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3978 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3981 { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
3982 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3983 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3984 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3985 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3986 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3987 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3988 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3989 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3990 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3992 /* subtitle options */
3993 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3994 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3995 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3998 { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
3999 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4000 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4001 { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
4003 /* G.2 grab options */
4004 { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
4005 { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
4008 { "muxrate", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_rate}, "set mux rate", "rate" },
4009 { "packetsize", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_packet_size}, "set packet size", "size" },
4010 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4011 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4013 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
4014 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
4016 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4020 static void show_banner(void)
4022 fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2004 Fabrice Bellard\n");
4023 fprintf(stderr, " configuration: " FFMPEG_CONFIGURATION "\n");
4024 fprintf(stderr, " libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
4025 fprintf(stderr, " libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
4026 fprintf(stderr, " libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
4027 fprintf(stderr, " built on " __DATE__ " " __TIME__);
4029 fprintf(stderr, ", gcc: " __VERSION__ "\n");
4031 fprintf(stderr, ", using a non-gcc compiler\n");
4035 static void show_license(void)
4040 "This program is free software; you can redistribute it and/or modify\n"
4041 "it under the terms of the GNU General Public License as published by\n"
4042 "the Free Software Foundation; either version 2 of the License, or\n"
4043 "(at your option) any later version.\n"
4045 "This program is distributed in the hope that it will be useful,\n"
4046 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4047 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
4048 "GNU General Public License for more details.\n"
4050 "You should have received a copy of the GNU General Public License\n"
4051 "along with this program; if not, write to the Free Software\n"
4052 "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
4056 "This library is free software; you can redistribute it and/or\n"
4057 "modify it under the terms of the GNU Lesser General Public\n"
4058 "License as published by the Free Software Foundation; either\n"
4059 "version 2 of the License, or (at your option) any later version.\n"
4061 "This library is distributed in the hope that it will be useful,\n"
4062 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4063 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
4064 "Lesser General Public License for more details.\n"
4066 "You should have received a copy of the GNU Lesser General Public\n"
4067 "License along with this library; if not, write to the Free Software\n"
4068 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
4074 static void show_help(void)
4077 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
4078 "Hyper fast Audio and Video encoder\n");
4080 show_help_options(options, "Main options:\n",
4081 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
4082 show_help_options(options, "\nVideo options:\n",
4083 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4085 show_help_options(options, "\nAdvanced Video options:\n",
4086 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4087 OPT_VIDEO | OPT_EXPERT);
4088 show_help_options(options, "\nAudio options:\n",
4089 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4091 show_help_options(options, "\nAdvanced Audio options:\n",
4092 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4093 OPT_AUDIO | OPT_EXPERT);
4094 show_help_options(options, "\nSubtitle options:\n",
4095 OPT_SUBTITLE | OPT_GRAB,
4097 show_help_options(options, "\nAudio/Video grab options:\n",
4100 show_help_options(options, "\nAdvanced options:\n",
4101 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4103 av_opt_show(avctx_opts, NULL);
4104 av_opt_show(avformat_opts, NULL);
4109 void parse_arg_file(const char *filename)
4111 opt_output_file(filename);
4114 int main(int argc, char **argv)
4121 avctx_opts= avcodec_alloc_context();
4122 avformat_opts = av_alloc_format_context();
4130 parse_options(argc, argv, options);
4132 /* file converter / grab */
4133 if (nb_output_files <= 0) {
4134 fprintf(stderr, "Must supply at least one output file\n");
4138 if (nb_input_files == 0) {
4144 av_encode(output_files, nb_output_files, input_files, nb_input_files,
4145 stream_maps, nb_stream_maps);
4146 ti = getutime() - ti;
4148 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4152 for(i=0;i<nb_output_files;i++) {
4153 /* maybe av_close_output_file ??? */
4154 AVFormatContext *s = output_files[i];
4156 if (!(s->oformat->flags & AVFMT_NOFILE))
4158 for(j=0;j<s->nb_streams;j++)
4159 av_free(s->streams[j]);
4162 for(i=0;i<nb_input_files;i++)
4163 av_close_input_file(input_files[i]);
4168 av_free(intra_matrix);
4170 av_free(inter_matrix);
4172 #ifdef POWERPC_PERFORMANCE_REPORT
4173 extern void powerpc_display_perf_report(void);
4174 powerpc_display_perf_report();
4175 #endif /* POWERPC_PERFORMANCE_REPORT */
4178 if (received_sigterm) {
4180 "Received signal %d: terminating.\n",
4181 (int) received_sigterm);
4185 exit(0); /* not all OS-es handle main() return value */