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 float video_qcomp = 0.5;
119 static uint16_t *intra_matrix = NULL;
120 static uint16_t *inter_matrix = NULL;
121 #if 0 //experimental, (can be removed)
122 static float video_rc_qsquish=1.0;
123 static float video_rc_qmod_amp=0;
124 static int video_rc_qmod_freq=0;
126 static char *video_rc_override_string=NULL;
127 static char *video_rc_eq="tex^qComp";
128 static int video_rc_buffer_size=0;
129 static float video_rc_buffer_aggressivity=1.0;
130 static float video_rc_initial_cplx=0;
131 static float video_b_qfactor = 1.25;
132 static float video_b_qoffset = 1.25;
133 static float video_i_qfactor = -0.8;
134 static float video_i_qoffset = 0.0;
135 static int me_method = ME_EPZS;
136 static int video_disable = 0;
137 static int video_discard = 0;
138 static int video_codec_id = CODEC_ID_NONE;
139 static int video_codec_tag = 0;
140 static int same_quality = 0;
141 static int b_frames = 0;
142 static int do_deinterlace = 0;
143 static int workaround_bugs = FF_BUG_AUTODETECT;
144 static int packet_size = 0;
145 static int error_rate = 0;
146 static int strict = 0;
147 static int top_field_first = -1;
148 static int sc_threshold = 0;
149 static int me_threshold = 0;
150 static int mb_threshold = 0;
151 static int intra_dc_precision = 8;
152 static int me_penalty_compensation= 256;
153 static int frame_skip_threshold= 0;
154 static int frame_skip_factor= 0;
155 static int frame_skip_exp= 0;
156 static int loop_input = 0;
157 static int loop_output = AVFMT_NOOUTPUTLOOP;
158 static int qp_hist = 0;
160 static int intra_only = 0;
161 static int audio_sample_rate = 44100;
162 static int audio_bit_rate = 64000;
163 #define QSCALE_NONE -99999
164 static float audio_qscale = QSCALE_NONE;
165 static int audio_disable = 0;
166 static int audio_channels = 1;
167 static int audio_codec_id = CODEC_ID_NONE;
168 static int audio_codec_tag = 0;
169 static char *audio_language = NULL;
171 static int subtitle_codec_id = CODEC_ID_NONE;
172 static char *subtitle_language = NULL;
174 static int mux_rate= 0;
175 static int mux_packet_size= 0;
176 static float mux_preload= 0.5;
177 static float mux_max_delay= 0.7;
179 static int64_t recording_time = 0;
180 static int64_t start_time = 0;
181 static int64_t rec_timestamp = 0;
182 static int64_t input_ts_offset = 0;
183 static int file_overwrite = 0;
184 static char *str_title = NULL;
185 static char *str_author = NULL;
186 static char *str_copyright = NULL;
187 static char *str_comment = NULL;
188 static char *str_album = NULL;
189 static int do_benchmark = 0;
190 static int do_hex_dump = 0;
191 static int do_pkt_dump = 0;
192 static int do_psnr = 0;
193 static int do_vstats = 0;
194 static int do_pass = 0;
195 static char *pass_logfilename = NULL;
196 static int audio_stream_copy = 0;
197 static int video_stream_copy = 0;
198 static int subtitle_stream_copy = 0;
199 static int video_sync_method= 1;
200 static int audio_sync_method= 0;
201 static int copy_ts= 0;
202 static int opt_shortest = 0; //
203 static int video_global_header = 0;
205 static int rate_emu = 0;
208 static const char *video_grab_format = "bktr";
210 #ifdef CONFIG_VIDEO4LINUX2
211 static const char *video_grab_format = "video4linux2";
213 static const char *video_grab_format = "video4linux";
216 static char *video_device = NULL;
217 static char *grab_device = NULL;
218 static int video_channel = 0;
219 static char *video_standard = "ntsc";
221 static const char *audio_grab_format = "audio_device";
222 static char *audio_device = NULL;
223 static int audio_volume = 256;
225 static int using_stdin = 0;
226 static int using_vhook = 0;
227 static int verbose = 1;
228 static int thread_count= 1;
229 static int q_pressed = 0;
230 static int me_range = 0;
231 static int64_t video_size = 0;
232 static int64_t audio_size = 0;
233 static int64_t extra_size = 0;
234 static int nb_frames_dup = 0;
235 static int nb_frames_drop = 0;
236 static int input_sync;
237 static int limit_filesize = 0; //
239 static int pgmyuv_compatibility_hack=0;
240 static int dts_delta_threshold = 10;
242 static int sws_flags = SWS_BICUBIC;
244 const char **opt_names=NULL;
245 int opt_name_count=0;
246 AVCodecContext *avctx_opts;
247 AVFormatContext *avformat_opts;
249 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
250 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
251 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
253 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
255 struct AVInputStream;
257 typedef struct AVOutputStream {
258 int file_index; /* file index */
259 int index; /* stream index in the output file */
260 int source_index; /* AVInputStream index */
261 AVStream *st; /* stream in the output file */
262 int encoding_needed; /* true if encoding needed for this stream */
264 /* input pts and corresponding output pts
266 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
267 struct AVInputStream *sync_ist; /* input stream to sync against */
268 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
271 AVFrame pict_tmp; /* temporary image for resampling */
272 struct SwsContext *img_resample_ctx; /* for image resampling */
276 int topBand; /* cropping area sizes */
280 int padtop; /* padding area sizes */
287 ReSampleContext *resample; /* for audio resampling */
288 FifoBuffer fifo; /* for compression: one audio fifo per codec */
292 typedef struct AVInputStream {
296 int discard; /* true if stream data should be discarded */
297 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
298 int64_t sample_index; /* current sample */
300 int64_t start; /* time when read started */
301 unsigned long frame; /* current frame */
302 int64_t next_pts; /* synthetic pts for cases where pkt.pts
304 int64_t pts; /* current pts */
305 int is_start; /* is 1 at the start and after a discontinuity */
308 typedef struct AVInputFile {
309 int eof_reached; /* true if eof reached */
310 int ist_index; /* index of first stream in ist_table */
311 int buffer_size; /* current total buffer size */
312 int buffer_size_max; /* buffer size at which we consider we can stop
314 int nb_streams; /* nb streams we are aware of */
319 /* init terminal so that we can grab keys */
320 static struct termios oldtty;
322 static void term_exit(void)
324 tcsetattr (0, TCSANOW, &oldtty);
327 static volatile sig_atomic_t received_sigterm = 0;
330 sigterm_handler(int sig)
332 received_sigterm = sig;
336 static void term_init(void)
343 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
344 |INLCR|IGNCR|ICRNL|IXON);
345 tty.c_oflag |= OPOST;
346 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
347 tty.c_cflag &= ~(CSIZE|PARENB);
352 tcsetattr (0, TCSANOW, &tty);
354 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
355 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
356 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
358 register a function to be called at normal program termination
361 #ifdef CONFIG_BEOS_NETSERVER
362 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
366 /* read a key without blocking */
367 static int read_key(void)
371 #ifndef CONFIG_BEOS_NETSERVER
379 n = select(1, &rfds, NULL, NULL, &tv);
391 static int decode_interrupt_cb(void)
393 return q_pressed || (q_pressed = read_key() == 'q');
398 static volatile int received_sigterm = 0;
400 /* no interactive support */
401 static void term_exit(void)
405 static void term_init(void)
409 static int read_key(void)
416 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
421 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
424 /* copy stream format */
425 s->nb_streams = ic->nb_streams;
426 for(i=0;i<ic->nb_streams;i++) {
429 // FIXME: a more elegant solution is needed
430 st = av_mallocz(sizeof(AVStream));
431 memcpy(st, ic->streams[i], sizeof(AVStream));
432 st->codec = avcodec_alloc_context();
433 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
437 av_close_input_file(ic);
442 get_sync_ipts(const AVOutputStream *ost)
444 const AVInputStream *ist = ost->sync_ist;
445 return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
448 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
450 AVPacket new_pkt= *pkt;
451 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
452 &new_pkt.data, &new_pkt.size,
453 pkt->data, pkt->size,
454 pkt->flags & PKT_FLAG_KEY);
457 new_pkt.destruct= av_destruct_packet;
464 av_interleaved_write_frame(s, pkt);
467 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
469 static void do_audio_out(AVFormatContext *s,
472 unsigned char *buf, int size)
475 static uint8_t *audio_buf = NULL;
476 static uint8_t *audio_out = NULL;
477 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
479 int size_out, frame_bytes, ret;
480 AVCodecContext *enc= ost->st->codec;
482 /* SC: dynamic allocation of buffers */
484 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
486 audio_out = av_malloc(audio_out_size);
487 if (!audio_buf || !audio_out)
488 return; /* Should signal an error ! */
490 if(audio_sync_method){
491 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
492 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2);
493 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
494 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
496 //FIXME resample delay
497 if(fabs(delta) > 50){
500 byte_delta= FFMAX(byte_delta, -size);
504 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
509 static uint8_t *input_tmp= NULL;
510 input_tmp= av_realloc(input_tmp, byte_delta + size);
512 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
515 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
517 memset(input_tmp, 0, byte_delta);
518 memcpy(input_tmp + byte_delta, buf, size);
522 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
524 }else if(audio_sync_method>1){
525 int comp= clip(delta, -audio_sync_method, audio_sync_method);
526 assert(ost->audio_resample);
528 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
529 // 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));
530 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
534 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
535 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2); //FIXME wrong
537 if (ost->audio_resample) {
539 size_out = audio_resample(ost->resample,
540 (short *)buftmp, (short *)buf,
541 size / (ist->st->codec->channels * 2));
542 size_out = size_out * enc->channels * 2;
548 /* now encode as many frames as possible */
549 if (enc->frame_size > 1) {
550 /* output resampled raw samples */
551 fifo_write(&ost->fifo, buftmp, size_out,
554 frame_bytes = enc->frame_size * 2 * enc->channels;
556 while (fifo_read(&ost->fifo, audio_buf, frame_bytes,
557 &ost->fifo.rptr) == 0) {
559 av_init_packet(&pkt);
561 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
564 pkt.stream_index= ost->index;
567 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
568 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
569 pkt.flags |= PKT_FLAG_KEY;
570 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
572 ost->sync_opts += enc->frame_size;
576 av_init_packet(&pkt);
578 ost->sync_opts += size_out / (2 * enc->channels);
580 /* output a pcm frame */
581 /* XXX: change encoding codec API to avoid this ? */
582 switch(enc->codec->id) {
583 case CODEC_ID_PCM_S32LE:
584 case CODEC_ID_PCM_S32BE:
585 case CODEC_ID_PCM_U32LE:
586 case CODEC_ID_PCM_U32BE:
587 size_out = size_out << 1;
589 case CODEC_ID_PCM_S24LE:
590 case CODEC_ID_PCM_S24BE:
591 case CODEC_ID_PCM_U24LE:
592 case CODEC_ID_PCM_U24BE:
593 case CODEC_ID_PCM_S24DAUD:
594 size_out = size_out / 2 * 3;
596 case CODEC_ID_PCM_S16LE:
597 case CODEC_ID_PCM_S16BE:
598 case CODEC_ID_PCM_U16LE:
599 case CODEC_ID_PCM_U16BE:
602 size_out = size_out >> 1;
605 ret = avcodec_encode_audio(enc, audio_out, size_out,
608 pkt.stream_index= ost->index;
611 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
612 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
613 pkt.flags |= PKT_FLAG_KEY;
614 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
618 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
622 AVPicture picture_tmp;
625 dec = ist->st->codec;
627 /* deinterlace : must be done before any resize */
628 if (do_deinterlace || using_vhook) {
631 /* create temporary picture */
632 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
633 buf = av_malloc(size);
637 picture2 = &picture_tmp;
638 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
641 if(avpicture_deinterlace(picture2, picture,
642 dec->pix_fmt, dec->width, dec->height) < 0) {
643 /* if error, do not deinterlace */
649 img_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
655 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
657 if (picture != picture2)
658 *picture = *picture2;
662 /* we begin to correct av delay at this threshold */
663 #define AV_DELAY_MAX 0.100
665 static void do_subtitle_out(AVFormatContext *s,
671 static uint8_t *subtitle_out = NULL;
672 int subtitle_out_max_size = 65536;
673 int subtitle_out_size, nb, i;
677 if (pts == AV_NOPTS_VALUE) {
678 fprintf(stderr, "Subtitle packets must have a pts\n");
682 enc = ost->st->codec;
685 subtitle_out = av_malloc(subtitle_out_max_size);
688 /* Note: DVB subtitle need one packet to draw them and one other
689 packet to clear them */
690 /* XXX: signal it in the codec context ? */
691 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
696 for(i = 0; i < nb; i++) {
697 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
698 subtitle_out_max_size, sub);
700 av_init_packet(&pkt);
701 pkt.stream_index = ost->index;
702 pkt.data = subtitle_out;
703 pkt.size = subtitle_out_size;
704 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);
705 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
706 /* XXX: the pts correction is handled here. Maybe handling
707 it in the codec would be better */
709 pkt.pts += 90 * sub->start_display_time;
711 pkt.pts += 90 * sub->end_display_time;
713 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
717 static int bit_buffer_size= 1024*256;
718 static uint8_t *bit_buffer= NULL;
720 static void do_video_out(AVFormatContext *s,
726 int nb_frames, i, ret;
727 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
728 AVFrame picture_crop_temp, picture_pad_temp;
729 uint8_t *buf = NULL, *buf1 = NULL;
730 AVCodecContext *enc, *dec;
732 avcodec_get_frame_defaults(&picture_crop_temp);
733 avcodec_get_frame_defaults(&picture_pad_temp);
735 enc = ost->st->codec;
736 dec = ist->st->codec;
738 /* by default, we output a single frame */
743 if(video_sync_method){
745 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
746 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
749 else if (vdelta > 1.1)
750 nb_frames = lrintf(vdelta);
751 //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);
755 fprintf(stderr, "*** drop!\n");
756 }else if (nb_frames > 1) {
757 nb_frames_dup += nb_frames;
759 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
762 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
764 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
768 if (ost->video_crop) {
769 if (img_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
770 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
773 formatted_picture = &picture_crop_temp;
775 formatted_picture = in_picture;
778 final_picture = formatted_picture;
779 padding_src = formatted_picture;
780 resampling_dst = &ost->pict_tmp;
781 if (ost->video_pad) {
782 final_picture = &ost->pict_tmp;
783 if (ost->video_resample) {
784 if (img_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
785 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
788 resampling_dst = &picture_pad_temp;
792 if (ost->video_resample) {
794 final_picture = &ost->pict_tmp;
795 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
796 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
799 if (ost->video_pad) {
800 img_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
801 enc->height, enc->width, enc->pix_fmt,
802 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
805 /* duplicates frame if needed */
806 for(i=0;i<nb_frames;i++) {
808 av_init_packet(&pkt);
809 pkt.stream_index= ost->index;
811 if (s->oformat->flags & AVFMT_RAWPICTURE) {
812 /* raw pictures are written as AVPicture structure to
813 avoid any copies. We support temorarily the older
815 AVFrame* old_frame = enc->coded_frame;
816 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
817 pkt.data= (uint8_t *)final_picture;
818 pkt.size= sizeof(AVPicture);
819 if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
820 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
821 if(dec->coded_frame && dec->coded_frame->key_frame)
822 pkt.flags |= PKT_FLAG_KEY;
824 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
825 enc->coded_frame = old_frame;
829 big_picture= *final_picture;
830 /* better than nothing: use input picture interlaced
832 big_picture.interlaced_frame = in_picture->interlaced_frame;
833 if(avctx_opts->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
834 if(top_field_first == -1)
835 big_picture.top_field_first = in_picture->top_field_first;
837 big_picture.top_field_first = top_field_first;
840 /* handles sameq here. This is not correct because it may
841 not be a global option */
843 big_picture.quality = ist->st->quality;
845 big_picture.quality = ost->st->quality;
847 big_picture.pict_type = 0;
848 // big_picture.pts = AV_NOPTS_VALUE;
849 big_picture.pts= ost->sync_opts;
850 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
851 //av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
852 ret = avcodec_encode_video(enc,
853 bit_buffer, bit_buffer_size,
855 //enc->frame_number = enc->real_pict_num;
857 pkt.data= bit_buffer;
859 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
860 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
861 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n",
862 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
863 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
865 if(enc->coded_frame && enc->coded_frame->key_frame)
866 pkt.flags |= PKT_FLAG_KEY;
867 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
869 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
870 // enc->frame_number-1, enc->real_pict_num, ret,
872 /* if two pass, output log */
873 if (ost->logfile && enc->stats_out) {
874 fprintf(ost->logfile, "%s", enc->stats_out);
886 static double psnr(double d){
887 if(d==0) return INFINITY;
888 return -10.0*log(d)/log(10.0);
891 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
894 static FILE *fvstats=NULL;
901 double ti1, bitrate, avg_bitrate;
905 today = localtime(&today2);
906 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
909 fvstats = fopen(filename,"w");
917 enc = ost->st->codec;
918 if (enc->codec_type == CODEC_TYPE_VIDEO) {
919 frame_number = ost->frame_number;
920 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
921 if (enc->flags&CODEC_FLAG_PSNR)
922 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
924 fprintf(fvstats,"f_size= %6d ", frame_size);
925 /* compute pts value */
926 ti1 = ost->sync_opts * av_q2d(enc->time_base);
930 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
931 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
932 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
933 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
934 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
938 static void print_report(AVFormatContext **output_files,
939 AVOutputStream **ost_table, int nb_ostreams,
944 AVFormatContext *oc, *os;
947 int frame_number, vid, i;
948 double bitrate, ti1, pts;
949 static int64_t last_time = -1;
950 static int qp_histogram[52];
952 if (!is_last_report) {
954 /* display the report every 0.5 seconds */
955 cur_time = av_gettime();
956 if (last_time == -1) {
957 last_time = cur_time;
960 if ((cur_time - last_time) < 500000)
962 last_time = cur_time;
966 oc = output_files[0];
968 total_size = url_ftell(&oc->pb);
973 for(i=0;i<nb_ostreams;i++) {
975 os = output_files[ost->file_index];
976 enc = ost->st->codec;
977 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
978 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
979 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
981 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
982 frame_number = ost->frame_number;
983 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%3.1f ",
984 frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
986 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
987 if(qp_hist && enc->coded_frame){
989 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
990 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
993 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
995 if (enc->flags&CODEC_FLAG_PSNR){
997 double error, error_sum=0;
998 double scale, scale_sum=0;
999 char type[3]= {'Y','U','V'};
1000 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1003 error= enc->error[j];
1004 scale= enc->width*enc->height*255.0*255.0*frame_number;
1006 error= enc->coded_frame->error[j];
1007 scale= enc->width*enc->height*255.0*255.0;
1012 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1014 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1018 /* compute min output value */
1019 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1020 if ((pts < ti1) && (pts > 0))
1026 if (verbose || is_last_report) {
1027 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1029 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1030 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1031 (double)total_size / 1024, ti1, bitrate);
1034 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1035 nb_frames_dup, nb_frames_drop);
1038 fprintf(stderr, "%s \r", buf);
1043 if (is_last_report && verbose >= 0){
1044 int64_t raw= audio_size + video_size + extra_size;
1045 fprintf(stderr, "\n");
1046 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1050 100.0*(total_size - raw)/raw
1055 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1056 static int output_packet(AVInputStream *ist, int ist_index,
1057 AVOutputStream **ost_table, int nb_ostreams,
1058 const AVPacket *pkt)
1060 AVFormatContext *os;
1061 AVOutputStream *ost;
1065 int data_size, got_picture;
1067 void *buffer_to_free;
1068 static unsigned int samples_size= 0;
1069 static short *samples= NULL;
1070 AVSubtitle subtitle, *subtitle_to_free;
1074 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1075 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1076 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1078 // assert(ist->pts == ist->next_pts);
1092 /* decode the packet if needed */
1093 data_buf = NULL; /* fail safe */
1095 subtitle_to_free = NULL;
1096 if (ist->decoding_needed) {
1097 switch(ist->st->codec->codec_type) {
1098 case CODEC_TYPE_AUDIO:{
1100 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1101 /* XXX: could avoid copy if PCM 16 bits with same
1102 endianness as CPU */
1103 ret = avcodec_decode_audio(ist->st->codec, samples, &data_size,
1109 /* Some bug in mpeg audio decoder gives */
1110 /* data_size < 0, it seems they are overflows */
1111 if (data_size <= 0) {
1112 /* no audio frame */
1115 data_buf = (uint8_t *)samples;
1116 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1117 (ist->st->codec->sample_rate * ist->st->codec->channels);
1119 case CODEC_TYPE_VIDEO:
1120 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1121 /* XXX: allocate picture correctly */
1122 avcodec_get_frame_defaults(&picture);
1124 ret = avcodec_decode_video(ist->st->codec,
1125 &picture, &got_picture, ptr, len);
1126 ist->st->quality= picture.quality;
1130 /* no picture yet */
1131 goto discard_packet;
1133 if (ist->st->codec->time_base.num != 0) {
1134 ist->next_pts += ((int64_t)AV_TIME_BASE *
1135 ist->st->codec->time_base.num) /
1136 ist->st->codec->time_base.den;
1140 case CODEC_TYPE_SUBTITLE:
1141 ret = avcodec_decode_subtitle(ist->st->codec,
1142 &subtitle, &got_subtitle, ptr, len);
1145 if (!got_subtitle) {
1146 goto discard_packet;
1148 subtitle_to_free = &subtitle;
1155 switch(ist->st->codec->codec_type) {
1156 case CODEC_TYPE_AUDIO:
1157 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1158 (ist->st->codec->sample_rate * ist->st->codec->channels);
1160 case CODEC_TYPE_VIDEO:
1161 if (ist->st->codec->time_base.num != 0) {
1162 ist->next_pts += ((int64_t)AV_TIME_BASE *
1163 ist->st->codec->time_base.num) /
1164 ist->st->codec->time_base.den;
1174 buffer_to_free = NULL;
1175 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1176 pre_process_video_frame(ist, (AVPicture *)&picture,
1180 // preprocess audio (volume)
1181 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1182 if (audio_volume != 256) {
1185 for(i=0;i<(data_size / sizeof(short));i++) {
1186 int v = ((*volp) * audio_volume + 128) >> 8;
1187 if (v < -32768) v = -32768;
1188 if (v > 32767) v = 32767;
1194 /* frame rate emulation */
1195 if (ist->st->codec->rate_emu) {
1196 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1197 int64_t now = av_gettime() - ist->start;
1205 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1206 is the one of the next displayed one */
1207 /* XXX: add mpeg4 too ? */
1208 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1209 if (ist->st->codec->pict_type != B_TYPE) {
1211 tmp = ist->last_ip_pts;
1212 ist->last_ip_pts = ist->frac_pts.val;
1213 ist->frac_pts.val = tmp;
1217 /* if output time reached then transcode raw format,
1218 encode packets and output them */
1219 if (start_time == 0 || ist->pts >= start_time)
1220 for(i=0;i<nb_ostreams;i++) {
1224 if (ost->source_index == ist_index) {
1225 os = output_files[ost->file_index];
1228 printf("%d: got pts=%0.3f %0.3f\n", i,
1229 (double)pkt->pts / AV_TIME_BASE,
1230 ((double)ist->pts / AV_TIME_BASE) -
1231 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1233 /* set the input output pts pairs */
1234 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1236 if (ost->encoding_needed) {
1237 switch(ost->st->codec->codec_type) {
1238 case CODEC_TYPE_AUDIO:
1239 do_audio_out(os, ost, ist, data_buf, data_size);
1241 case CODEC_TYPE_VIDEO:
1242 do_video_out(os, ost, ist, &picture, &frame_size);
1243 video_size += frame_size;
1244 if (do_vstats && frame_size)
1245 do_video_stats(os, ost, frame_size);
1247 case CODEC_TYPE_SUBTITLE:
1248 do_subtitle_out(os, ost, ist, &subtitle,
1255 AVFrame avframe; //FIXME/XXX remove this
1257 av_init_packet(&opkt);
1259 /* no reencoding needed : output the packet directly */
1260 /* force the input stream PTS */
1262 avcodec_get_frame_defaults(&avframe);
1263 ost->st->codec->coded_frame= &avframe;
1264 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1266 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1267 audio_size += data_size;
1268 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1269 video_size += data_size;
1273 opkt.stream_index= ost->index;
1274 if(pkt->pts != AV_NOPTS_VALUE)
1275 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);
1277 opkt.pts= AV_NOPTS_VALUE;
1281 if (pkt->dts == AV_NOPTS_VALUE)
1282 dts = ist->next_pts;
1284 dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1285 opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
1287 opkt.flags= pkt->flags;
1289 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1290 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1291 opkt.destruct= av_destruct_packet;
1293 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1294 ost->st->codec->frame_number++;
1295 ost->frame_number++;
1296 av_free_packet(&opkt);
1300 av_free(buffer_to_free);
1301 /* XXX: allocate the subtitles in the codec ? */
1302 if (subtitle_to_free) {
1303 if (subtitle_to_free->rects != NULL) {
1304 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1305 av_free(subtitle_to_free->rects[i].bitmap);
1306 av_free(subtitle_to_free->rects[i].rgba_palette);
1308 av_freep(&subtitle_to_free->rects);
1310 subtitle_to_free->num_rects = 0;
1311 subtitle_to_free = NULL;
1318 for(i=0;i<nb_ostreams;i++) {
1320 if (ost->source_index == ist_index) {
1321 AVCodecContext *enc= ost->st->codec;
1322 os = output_files[ost->file_index];
1324 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1326 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1329 if (ost->encoding_needed) {
1333 av_init_packet(&pkt);
1334 pkt.stream_index= ost->index;
1336 switch(ost->st->codec->codec_type) {
1337 case CODEC_TYPE_AUDIO:
1338 fifo_bytes = fifo_size(&ost->fifo, NULL);
1340 /* encode any samples remaining in fifo */
1341 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1342 int fs_tmp = enc->frame_size;
1343 enc->frame_size = fifo_bytes / (2 * enc->channels);
1344 if(fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes,
1345 &ost->fifo.rptr) == 0) {
1346 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1348 enc->frame_size = fs_tmp;
1351 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1354 pkt.flags |= PKT_FLAG_KEY;
1356 case CODEC_TYPE_VIDEO:
1357 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1359 if(enc->coded_frame && enc->coded_frame->key_frame)
1360 pkt.flags |= PKT_FLAG_KEY;
1361 if (ost->logfile && enc->stats_out) {
1362 fprintf(ost->logfile, "%s", enc->stats_out);
1371 pkt.data= bit_buffer;
1373 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1374 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1375 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1389 * The following code is the main loop of the file converter
1391 static int av_encode(AVFormatContext **output_files,
1392 int nb_output_files,
1393 AVFormatContext **input_files,
1395 AVStreamMap *stream_maps, int nb_stream_maps)
1397 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1398 AVFormatContext *is, *os;
1399 AVCodecContext *codec, *icodec;
1400 AVOutputStream *ost, **ost_table = NULL;
1401 AVInputStream *ist, **ist_table = NULL;
1402 AVInputFile *file_table;
1403 AVFormatContext *stream_no_data;
1406 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1410 /* input stream init */
1412 for(i=0;i<nb_input_files;i++) {
1413 is = input_files[i];
1414 file_table[i].ist_index = j;
1415 file_table[i].nb_streams = is->nb_streams;
1416 j += is->nb_streams;
1420 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1424 for(i=0;i<nb_istreams;i++) {
1425 ist = av_mallocz(sizeof(AVInputStream));
1431 for(i=0;i<nb_input_files;i++) {
1432 is = input_files[i];
1433 for(k=0;k<is->nb_streams;k++) {
1434 ist = ist_table[j++];
1435 ist->st = is->streams[k];
1436 ist->file_index = i;
1438 ist->discard = 1; /* the stream is discarded by default
1441 if (ist->st->codec->rate_emu) {
1442 ist->start = av_gettime();
1448 /* output stream init */
1450 for(i=0;i<nb_output_files;i++) {
1451 os = output_files[i];
1452 nb_ostreams += os->nb_streams;
1454 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1455 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1459 /* Sanity check the mapping args -- do the input files & streams exist? */
1460 for(i=0;i<nb_stream_maps;i++) {
1461 int fi = stream_maps[i].file_index;
1462 int si = stream_maps[i].stream_index;
1464 if (fi < 0 || fi > nb_input_files - 1 ||
1465 si < 0 || si > file_table[fi].nb_streams - 1) {
1466 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1469 fi = stream_maps[i].sync_file_index;
1470 si = stream_maps[i].sync_stream_index;
1471 if (fi < 0 || fi > nb_input_files - 1 ||
1472 si < 0 || si > file_table[fi].nb_streams - 1) {
1473 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1478 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1481 for(i=0;i<nb_ostreams;i++) {
1482 ost = av_mallocz(sizeof(AVOutputStream));
1489 for(k=0;k<nb_output_files;k++) {
1490 os = output_files[k];
1491 for(i=0;i<os->nb_streams;i++) {
1493 ost = ost_table[n++];
1494 ost->file_index = k;
1496 ost->st = os->streams[i];
1497 if (nb_stream_maps > 0) {
1498 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1499 stream_maps[n-1].stream_index;
1501 /* Sanity check that the stream types match */
1502 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1503 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1504 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1505 ost->file_index, ost->index);
1510 /* get corresponding input stream index : we select the first one with the right type */
1512 for(j=0;j<nb_istreams;j++) {
1515 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1516 ost->source_index = j;
1523 /* try again and reuse existing stream */
1524 for(j=0;j<nb_istreams;j++) {
1526 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1527 ost->source_index = j;
1532 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1533 ost->file_index, ost->index);
1538 ist = ist_table[ost->source_index];
1540 ost->sync_ist = (nb_stream_maps > 0) ?
1541 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1542 stream_maps[n-1].sync_stream_index] : ist;
1546 /* for each output stream, we compute the right encoding parameters */
1547 for(i=0;i<nb_ostreams;i++) {
1549 ist = ist_table[ost->source_index];
1551 codec = ost->st->codec;
1552 icodec = ist->st->codec;
1554 if (ost->st->stream_copy) {
1555 /* if stream_copy is selected, no need to decode or encode */
1556 codec->codec_id = icodec->codec_id;
1557 codec->codec_type = icodec->codec_type;
1558 if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1559 codec->bit_rate = icodec->bit_rate;
1560 codec->extradata= icodec->extradata;
1561 codec->extradata_size= icodec->extradata_size;
1562 codec->time_base = icodec->time_base;
1563 switch(codec->codec_type) {
1564 case CODEC_TYPE_AUDIO:
1565 codec->sample_rate = icodec->sample_rate;
1566 codec->channels = icodec->channels;
1567 codec->frame_size = icodec->frame_size;
1568 codec->block_align= icodec->block_align;
1570 case CODEC_TYPE_VIDEO:
1571 codec->pix_fmt = icodec->pix_fmt;
1572 codec->width = icodec->width;
1573 codec->height = icodec->height;
1574 codec->has_b_frames = icodec->has_b_frames;
1576 case CODEC_TYPE_SUBTITLE:
1582 switch(codec->codec_type) {
1583 case CODEC_TYPE_AUDIO:
1584 if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1587 if (codec->channels == icodec->channels &&
1588 codec->sample_rate == icodec->sample_rate) {
1589 ost->audio_resample = 0;
1591 if (codec->channels != icodec->channels &&
1592 (icodec->codec_id == CODEC_ID_AC3 ||
1593 icodec->codec_id == CODEC_ID_DTS)) {
1594 /* Special case for 5:1 AC3 and DTS input */
1595 /* and mono or stereo output */
1596 /* Request specific number of channels */
1597 icodec->channels = codec->channels;
1598 if (codec->sample_rate == icodec->sample_rate)
1599 ost->audio_resample = 0;
1601 ost->audio_resample = 1;
1604 ost->audio_resample = 1;
1607 if(audio_sync_method>1)
1608 ost->audio_resample = 1;
1610 if(ost->audio_resample){
1611 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1612 codec->sample_rate, icodec->sample_rate);
1614 printf("Can't resample. Aborting.\n");
1618 ist->decoding_needed = 1;
1619 ost->encoding_needed = 1;
1621 case CODEC_TYPE_VIDEO:
1622 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1623 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1624 ost->video_resample = ((codec->width != icodec->width -
1625 (frame_leftBand + frame_rightBand) +
1626 (frame_padleft + frame_padright)) ||
1627 (codec->height != icodec->height -
1628 (frame_topBand + frame_bottomBand) +
1629 (frame_padtop + frame_padbottom)) ||
1630 (codec->pix_fmt != icodec->pix_fmt));
1631 if (ost->video_crop) {
1632 ost->topBand = frame_topBand;
1633 ost->leftBand = frame_leftBand;
1635 if (ost->video_pad) {
1636 ost->padtop = frame_padtop;
1637 ost->padleft = frame_padleft;
1638 ost->padbottom = frame_padbottom;
1639 ost->padright = frame_padright;
1640 if (!ost->video_resample) {
1641 avcodec_get_frame_defaults(&ost->pict_tmp);
1642 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1643 codec->width, codec->height ) )
1647 if (ost->video_resample) {
1648 avcodec_get_frame_defaults(&ost->pict_tmp);
1649 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1650 codec->width, codec->height ) )
1653 ost->img_resample_ctx = sws_getContext(
1654 icodec->width - (frame_leftBand + frame_rightBand),
1655 icodec->height - (frame_topBand + frame_bottomBand),
1657 codec->width - (frame_padleft + frame_padright),
1658 codec->height - (frame_padtop + frame_padbottom),
1660 sws_flags, NULL, NULL, NULL);
1661 if (ost->img_resample_ctx == NULL) {
1662 fprintf(stderr, "Cannot get resampling context\n");
1665 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1667 ost->encoding_needed = 1;
1668 ist->decoding_needed = 1;
1670 case CODEC_TYPE_SUBTITLE:
1671 ost->encoding_needed = 1;
1672 ist->decoding_needed = 1;
1679 if (ost->encoding_needed &&
1680 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1681 char logfilename[1024];
1686 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1688 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1689 if (codec->flags & CODEC_FLAG_PASS1) {
1690 f = fopen(logfilename, "w");
1692 perror(logfilename);
1697 /* read the log file */
1698 f = fopen(logfilename, "r");
1700 perror(logfilename);
1703 fseek(f, 0, SEEK_END);
1705 fseek(f, 0, SEEK_SET);
1706 logbuffer = av_malloc(size + 1);
1708 fprintf(stderr, "Could not allocate log buffer\n");
1711 size = fread(logbuffer, 1, size, f);
1713 logbuffer[size] = '\0';
1714 codec->stats_in = logbuffer;
1718 if(codec->codec_type == CODEC_TYPE_VIDEO){
1719 int size= codec->width * codec->height;
1720 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1725 bit_buffer = av_malloc(bit_buffer_size);
1729 /* dump the file output parameters - cannot be done before in case
1731 for(i=0;i<nb_output_files;i++) {
1732 dump_format(output_files[i], i, output_files[i]->filename, 1);
1735 /* dump the stream mapping */
1737 fprintf(stderr, "Stream mapping:\n");
1738 for(i=0;i<nb_ostreams;i++) {
1740 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1741 ist_table[ost->source_index]->file_index,
1742 ist_table[ost->source_index]->index,
1745 if (ost->sync_ist != ist_table[ost->source_index])
1746 fprintf(stderr, " [sync #%d.%d]",
1747 ost->sync_ist->file_index,
1748 ost->sync_ist->index);
1749 fprintf(stderr, "\n");
1753 /* open each encoder */
1754 for(i=0;i<nb_ostreams;i++) {
1756 if (ost->encoding_needed) {
1758 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1760 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1761 ost->file_index, ost->index);
1764 if (avcodec_open(ost->st->codec, codec) < 0) {
1765 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1766 ost->file_index, ost->index);
1769 extra_size += ost->st->codec->extradata_size;
1773 /* open each decoder */
1774 for(i=0;i<nb_istreams;i++) {
1776 if (ist->decoding_needed) {
1778 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1780 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1781 ist->st->codec->codec_id, ist->file_index, ist->index);
1784 if (avcodec_open(ist->st->codec, codec) < 0) {
1785 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1786 ist->file_index, ist->index);
1789 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1790 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1795 for(i=0;i<nb_istreams;i++) {
1797 is = input_files[ist->file_index];
1799 ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1800 if(ist->st->start_time == AV_NOPTS_VALUE)
1802 if(input_files_ts_offset[ist->file_index])
1803 ist->next_pts= AV_NOPTS_VALUE;
1807 /* compute buffer size max (should use a complete heuristic) */
1808 for(i=0;i<nb_input_files;i++) {
1809 file_table[i].buffer_size_max = 2048;
1812 /* set meta data information from input file if required */
1813 for (i=0;i<nb_meta_data_maps;i++) {
1814 AVFormatContext *out_file;
1815 AVFormatContext *in_file;
1817 int out_file_index = meta_data_maps[i].out_file;
1818 int in_file_index = meta_data_maps[i].in_file;
1819 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1820 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1824 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1825 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1830 out_file = output_files[out_file_index];
1831 in_file = input_files[in_file_index];
1833 strcpy(out_file->title, in_file->title);
1834 strcpy(out_file->author, in_file->author);
1835 strcpy(out_file->copyright, in_file->copyright);
1836 strcpy(out_file->comment, in_file->comment);
1837 strcpy(out_file->album, in_file->album);
1838 out_file->year = in_file->year;
1839 out_file->track = in_file->track;
1840 strcpy(out_file->genre, in_file->genre);
1843 /* open files and write file headers */
1844 for(i=0;i<nb_output_files;i++) {
1845 os = output_files[i];
1846 if (av_write_header(os) < 0) {
1847 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1854 if ( !using_stdin && verbose >= 0) {
1855 fprintf(stderr, "Press [q] to stop encoding\n");
1856 url_set_interrupt_cb(decode_interrupt_cb);
1864 for(; received_sigterm == 0;) {
1865 int file_index, ist_index;
1873 /* if 'q' pressed, exits */
1877 /* read_key() returns 0 on EOF */
1883 /* select the stream that we must read now by looking at the
1884 smallest output pts */
1886 for(i=0;i<nb_ostreams;i++) {
1889 os = output_files[ost->file_index];
1890 ist = ist_table[ost->source_index];
1891 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1892 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1894 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1895 ipts = (double)ist->pts;
1896 if (!file_table[ist->file_index].eof_reached){
1897 if(ipts < ipts_min) {
1899 if(input_sync ) file_index = ist->file_index;
1901 if(opts < opts_min) {
1903 if(!input_sync) file_index = ist->file_index;
1906 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1911 /* if none, if is finished */
1912 if (file_index < 0) {
1916 /* finish if recording time exhausted */
1917 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1920 /* finish if limit size exhausted */
1921 if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1924 /* read a frame from it and output it in the fifo */
1925 is = input_files[file_index];
1926 if (av_read_frame(is, &pkt) < 0) {
1927 file_table[file_index].eof_reached = 1;
1928 if (opt_shortest) break; else continue; //
1932 stream_no_data = is;
1937 av_pkt_dump(stdout, &pkt, do_hex_dump);
1939 /* the following test is needed in case new streams appear
1940 dynamically in stream : we ignore them */
1941 if (pkt.stream_index >= file_table[file_index].nb_streams)
1942 goto discard_packet;
1943 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1944 ist = ist_table[ist_index];
1946 goto discard_packet;
1948 // 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);
1949 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1950 int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1951 if(ABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1952 input_files_ts_offset[ist->file_index]-= delta;
1954 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1955 for(i=0; i<file_table[file_index].nb_streams; i++){
1956 int index= file_table[file_index].ist_index + i;
1957 ist_table[index]->next_pts += delta;
1958 ist_table[index]->is_start=1;
1963 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1964 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1967 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1968 ist->file_index, ist->index);
1970 av_free_packet(&pkt);
1975 av_free_packet(&pkt);
1977 /* dump report by using the output first video and audio streams */
1978 print_report(output_files, ost_table, nb_ostreams, 0);
1981 /* at the end of stream, we must flush the decoder buffers */
1982 for(i=0;i<nb_istreams;i++) {
1984 if (ist->decoding_needed) {
1985 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1991 /* write the trailer if needed and close file */
1992 for(i=0;i<nb_output_files;i++) {
1993 os = output_files[i];
1994 av_write_trailer(os);
1997 /* dump report by using the first video and audio streams */
1998 print_report(output_files, ost_table, nb_ostreams, 1);
2000 /* close each encoder */
2001 for(i=0;i<nb_ostreams;i++) {
2003 if (ost->encoding_needed) {
2004 av_freep(&ost->st->codec->stats_in);
2005 avcodec_close(ost->st->codec);
2009 /* close each decoder */
2010 for(i=0;i<nb_istreams;i++) {
2012 if (ist->decoding_needed) {
2013 avcodec_close(ist->st->codec);
2021 av_freep(&bit_buffer);
2022 av_free(file_table);
2025 for(i=0;i<nb_istreams;i++) {
2032 for(i=0;i<nb_ostreams;i++) {
2036 fclose(ost->logfile);
2037 ost->logfile = NULL;
2039 fifo_free(&ost->fifo); /* works even if fifo is not
2040 initialized but set to zero */
2041 av_free(ost->pict_tmp.data[0]);
2042 if (ost->video_resample)
2043 sws_freeContext(ost->img_resample_ctx);
2044 if (ost->audio_resample)
2045 audio_resample_close(ost->resample);
2058 int file_read(const char *filename)
2061 unsigned char buffer[1024];
2064 if (url_open(&h, filename, O_RDONLY) < 0) {
2065 printf("could not open '%s'\n", filename);
2069 len = url_read(h, buffer, sizeof(buffer));
2072 for(i=0;i<len;i++) putchar(buffer[i]);
2079 static void opt_image_format(const char *arg)
2083 for(f = first_image_format; f != NULL; f = f->next) {
2084 if (!strcmp(arg, f->name))
2088 fprintf(stderr, "Unknown image format: '%s'\n", arg);
2094 static void opt_format(const char *arg)
2096 /* compatibility stuff for pgmyuv */
2097 if (!strcmp(arg, "pgmyuv")) {
2098 pgmyuv_compatibility_hack=1;
2099 // opt_image_format(arg);
2103 file_iformat = av_find_input_format(arg);
2104 file_oformat = guess_format(arg, NULL, NULL);
2105 if (!file_iformat && !file_oformat) {
2106 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2111 static void opt_video_bitrate_tolerance(const char *arg)
2113 video_bit_rate_tolerance = atoi(arg) * 1000;
2116 static void opt_video_buffer_size(const char *arg)
2118 video_rc_buffer_size = atoi(arg) * 8*1024;
2121 static void opt_video_rc_eq(char *arg)
2126 static void opt_video_rc_override_string(char *arg)
2128 video_rc_override_string = arg;
2132 static void opt_workaround_bugs(const char *arg)
2134 workaround_bugs = atoi(arg);
2137 static void opt_me_threshold(const char *arg)
2139 me_threshold = atoi(arg);
2142 static void opt_mb_threshold(const char *arg)
2144 mb_threshold = atoi(arg);
2147 static void opt_verbose(const char *arg)
2149 verbose = atoi(arg);
2150 av_log_set_level(atoi(arg));
2153 static void opt_frame_rate(const char *arg)
2155 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2156 fprintf(stderr, "Incorrect frame rate\n");
2161 static void opt_frame_crop_top(const char *arg)
2163 frame_topBand = atoi(arg);
2164 if (frame_topBand < 0) {
2165 fprintf(stderr, "Incorrect top crop size\n");
2168 if ((frame_topBand % 2) != 0) {
2169 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2172 if ((frame_topBand) >= frame_height){
2173 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2176 frame_height -= frame_topBand;
2179 static void opt_frame_crop_bottom(const char *arg)
2181 frame_bottomBand = atoi(arg);
2182 if (frame_bottomBand < 0) {
2183 fprintf(stderr, "Incorrect bottom crop size\n");
2186 if ((frame_bottomBand % 2) != 0) {
2187 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2190 if ((frame_bottomBand) >= frame_height){
2191 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2194 frame_height -= frame_bottomBand;
2197 static void opt_frame_crop_left(const char *arg)
2199 frame_leftBand = atoi(arg);
2200 if (frame_leftBand < 0) {
2201 fprintf(stderr, "Incorrect left crop size\n");
2204 if ((frame_leftBand % 2) != 0) {
2205 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2208 if ((frame_leftBand) >= frame_width){
2209 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2212 frame_width -= frame_leftBand;
2215 static void opt_frame_crop_right(const char *arg)
2217 frame_rightBand = atoi(arg);
2218 if (frame_rightBand < 0) {
2219 fprintf(stderr, "Incorrect right crop size\n");
2222 if ((frame_rightBand % 2) != 0) {
2223 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2226 if ((frame_rightBand) >= frame_width){
2227 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2230 frame_width -= frame_rightBand;
2233 static void opt_frame_size(const char *arg)
2235 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2236 fprintf(stderr, "Incorrect frame size\n");
2239 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2240 fprintf(stderr, "Frame size must be a multiple of 2\n");
2246 #define SCALEBITS 10
2247 #define ONE_HALF (1 << (SCALEBITS - 1))
2248 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2250 #define RGB_TO_Y(r, g, b) \
2251 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2252 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2254 #define RGB_TO_U(r1, g1, b1, shift)\
2255 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2256 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2258 #define RGB_TO_V(r1, g1, b1, shift)\
2259 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2260 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2262 static void opt_pad_color(const char *arg) {
2263 /* Input is expected to be six hex digits similar to
2264 how colors are expressed in html tags (but without the #) */
2265 int rgb = strtol(arg, NULL, 16);
2269 g = ((rgb >> 8) & 255);
2272 padcolor[0] = RGB_TO_Y(r,g,b);
2273 padcolor[1] = RGB_TO_U(r,g,b,0);
2274 padcolor[2] = RGB_TO_V(r,g,b,0);
2277 static void opt_frame_pad_top(const char *arg)
2279 frame_padtop = atoi(arg);
2280 if (frame_padtop < 0) {
2281 fprintf(stderr, "Incorrect top pad size\n");
2284 if ((frame_padtop % 2) != 0) {
2285 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2290 static void opt_frame_pad_bottom(const char *arg)
2292 frame_padbottom = atoi(arg);
2293 if (frame_padbottom < 0) {
2294 fprintf(stderr, "Incorrect bottom pad size\n");
2297 if ((frame_padbottom % 2) != 0) {
2298 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2304 static void opt_frame_pad_left(const char *arg)
2306 frame_padleft = atoi(arg);
2307 if (frame_padleft < 0) {
2308 fprintf(stderr, "Incorrect left pad size\n");
2311 if ((frame_padleft % 2) != 0) {
2312 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2318 static void opt_frame_pad_right(const char *arg)
2320 frame_padright = atoi(arg);
2321 if (frame_padright < 0) {
2322 fprintf(stderr, "Incorrect right pad size\n");
2325 if ((frame_padright % 2) != 0) {
2326 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2332 static void opt_frame_pix_fmt(const char *arg)
2334 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2337 static void opt_frame_aspect_ratio(const char *arg)
2343 p = strchr(arg, ':');
2345 x = strtol(arg, (char **)&arg, 10);
2347 y = strtol(arg+1, (char **)&arg, 10);
2349 ar = (double)x / (double)y;
2351 ar = strtod(arg, (char **)&arg);
2354 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2357 frame_aspect_ratio = ar;
2360 static void opt_b_frames(const char *arg)
2362 b_frames = atoi(arg);
2363 if (b_frames > FF_MAX_B_FRAMES) {
2364 fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2366 } else if (b_frames < 1) {
2367 fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2372 static void opt_qscale(const char *arg)
2374 video_qscale = atof(arg);
2375 if (video_qscale <= 0 ||
2376 video_qscale > 255) {
2377 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2382 static void opt_qsquish(const char *arg)
2384 video_qsquish = atof(arg);
2385 if (video_qsquish < 0.0 ||
2386 video_qsquish > 99.0) {
2387 fprintf(stderr, "qsquish must be >= 0.0 and <= 99.0\n");
2392 static void opt_lmax(const char *arg)
2394 video_lmax = atof(arg)*FF_QP2LAMBDA;
2397 static void opt_lmin(const char *arg)
2399 video_lmin = atof(arg)*FF_QP2LAMBDA;
2402 static void opt_qmin(const char *arg)
2404 video_qmin = atoi(arg);
2405 if (video_qmin < 1 ||
2407 fprintf(stderr, "qmin must be >= 1 and <= 51\n");
2412 static void opt_qmax(const char *arg)
2414 video_qmax = atoi(arg);
2415 if (video_qmax < 1 ||
2417 fprintf(stderr, "qmax must be >= 1 and <= 51\n");
2422 static void opt_mb_lmin(const char *arg)
2424 video_mb_lmin = atof(arg)*FF_QP2LAMBDA;
2425 if (video_mb_lmin < 1 ||
2426 video_mb_lmin > FF_LAMBDA_MAX) {
2427 fprintf(stderr, "mblmin must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2432 static void opt_mb_lmax(const char *arg)
2434 video_mb_lmax = atof(arg)*FF_QP2LAMBDA;
2435 if (video_mb_lmax < 1 ||
2436 video_mb_lmax > FF_LAMBDA_MAX) {
2437 fprintf(stderr, "mblmax must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2442 static void opt_qdiff(const char *arg)
2444 video_qdiff = atoi(arg);
2445 if (video_qdiff < 0 ||
2447 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2452 static void opt_qcomp(const char *arg)
2454 video_qcomp = atof(arg);
2457 static void opt_rc_initial_cplx(const char *arg)
2459 video_rc_initial_cplx = atof(arg);
2461 static void opt_b_qfactor(const char *arg)
2463 video_b_qfactor = atof(arg);
2465 static void opt_i_qfactor(const char *arg)
2467 video_i_qfactor = atof(arg);
2469 static void opt_b_qoffset(const char *arg)
2471 video_b_qoffset = atof(arg);
2473 static void opt_i_qoffset(const char *arg)
2475 video_i_qoffset = atof(arg);
2478 static void opt_packet_size(const char *arg)
2480 packet_size= atoi(arg);
2483 static void opt_error_rate(const char *arg)
2485 error_rate= atoi(arg);
2488 static void opt_strict(const char *arg)
2493 static void opt_top_field_first(const char *arg)
2495 top_field_first= atoi(arg);
2498 static void opt_sc_threshold(const char *arg)
2500 sc_threshold= atoi(arg);
2503 static void opt_me_range(const char *arg)
2505 me_range = atoi(arg);
2508 static void opt_thread_count(const char *arg)
2510 thread_count= atoi(arg);
2511 #if !defined(HAVE_THREADS)
2513 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2517 static void opt_audio_bitrate(const char *arg)
2519 audio_bit_rate = atoi(arg) * 1000;
2522 static void opt_audio_rate(const char *arg)
2524 audio_sample_rate = atoi(arg);
2527 static void opt_audio_channels(const char *arg)
2529 audio_channels = atoi(arg);
2532 static void opt_video_device(const char *arg)
2534 video_device = av_strdup(arg);
2537 static void opt_grab_device(const char *arg)
2539 grab_device = av_strdup(arg);
2542 static void opt_video_channel(const char *arg)
2544 video_channel = strtol(arg, NULL, 0);
2547 static void opt_video_standard(const char *arg)
2549 video_standard = av_strdup(arg);
2552 static void opt_audio_device(const char *arg)
2554 audio_device = av_strdup(arg);
2557 static void opt_codec(int *pstream_copy, int *pcodec_id,
2558 int codec_type, const char *arg)
2562 if (!strcmp(arg, "copy")) {
2567 if (!strcmp(p->name, arg) && p->type == codec_type)
2572 fprintf(stderr, "Unknown codec '%s'\n", arg);
2580 static void opt_audio_codec(const char *arg)
2582 opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2585 static void opt_audio_tag(const char *arg)
2588 audio_codec_tag= strtol(arg, &tail, 0);
2591 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2594 static void opt_video_tag(const char *arg)
2597 video_codec_tag= strtol(arg, &tail, 0);
2600 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2603 static void add_frame_hooker(const char *arg)
2608 char *args = av_strdup(arg);
2612 argv[0] = strtok(args, " ");
2613 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2616 i = frame_hook_add(argc, argv);
2619 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2624 const char *motion_str[] = {
2637 static void opt_motion_estimation(const char *arg)
2643 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2646 if (!strcmp(*p, arg))
2650 me_method = (p - motion_str) + 1;
2653 static void opt_video_codec(const char *arg)
2655 opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2658 static void opt_subtitle_codec(const char *arg)
2660 opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2663 static void opt_map(const char *arg)
2669 m = &stream_maps[nb_stream_maps++];
2671 m->file_index = strtol(arg, (char **)&p, 0);
2675 m->stream_index = strtol(p, (char **)&p, 0);
2678 m->sync_file_index = strtol(p, (char **)&p, 0);
2681 m->sync_stream_index = strtol(p, (char **)&p, 0);
2683 m->sync_file_index = m->file_index;
2684 m->sync_stream_index = m->stream_index;
2688 static void opt_map_meta_data(const char *arg)
2694 m = &meta_data_maps[nb_meta_data_maps++];
2696 m->out_file = strtol(arg, (char **)&p, 0);
2700 m->in_file = strtol(p, (char **)&p, 0);
2703 static void opt_recording_time(const char *arg)
2705 recording_time = parse_date(arg, 1);
2708 static void opt_start_time(const char *arg)
2710 start_time = parse_date(arg, 1);
2713 static void opt_rec_timestamp(const char *arg)
2715 rec_timestamp = parse_date(arg, 0) / 1000000;
2718 static void opt_input_ts_offset(const char *arg)
2720 input_ts_offset = parse_date(arg, 1);
2723 static void opt_input_file(const char *filename)
2725 AVFormatContext *ic;
2726 AVFormatParameters params, *ap = ¶ms;
2727 int err, i, ret, rfps, rfps_base;
2730 if (!strcmp(filename, "-"))
2733 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2734 !strcmp( filename, "/dev/stdin" );
2736 /* get default parameters from command line */
2737 ic = av_alloc_format_context();
2739 memset(ap, 0, sizeof(*ap));
2740 ap->prealloced_context = 1;
2741 ap->sample_rate = audio_sample_rate;
2742 ap->channels = audio_channels;
2743 ap->time_base.den = frame_rate;
2744 ap->time_base.num = frame_rate_base;
2745 ap->width = frame_width + frame_padleft + frame_padright;
2746 ap->height = frame_height + frame_padtop + frame_padbottom;
2747 ap->image_format = image_format;
2748 ap->pix_fmt = frame_pix_fmt;
2749 ap->device = grab_device;
2750 ap->channel = video_channel;
2751 ap->standard = video_standard;
2752 ap->video_codec_id = video_codec_id;
2753 ap->audio_codec_id = audio_codec_id;
2754 if(pgmyuv_compatibility_hack)
2755 ap->video_codec_id= CODEC_ID_PGMYUV;
2757 for(i=0; i<opt_name_count; i++){
2759 double d= av_get_double(avformat_opts, opt_names[i], &opt);
2760 if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2761 av_set_double(ic, opt_names[i], d);
2763 /* open the input file with generic libav function */
2764 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2766 print_error(filename, err);
2770 ic->loop_input = loop_input;
2772 /* If not enough info to get the stream parameters, we decode the
2773 first frames to get it. (used in mpeg case for example) */
2774 ret = av_find_stream_info(ic);
2775 if (ret < 0 && verbose >= 0) {
2776 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2780 timestamp = start_time;
2781 /* add the stream start time */
2782 if (ic->start_time != AV_NOPTS_VALUE)
2783 timestamp += ic->start_time;
2785 /* if seeking requested, we execute it */
2786 if (start_time != 0) {
2787 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2789 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2790 filename, (double)timestamp / AV_TIME_BASE);
2792 /* reset seek info */
2796 /* update the current parameters so that they match the one of the input stream */
2797 for(i=0;i<ic->nb_streams;i++) {
2799 AVCodecContext *enc = ic->streams[i]->codec;
2800 #if defined(HAVE_THREADS)
2802 avcodec_thread_init(enc, thread_count);
2804 enc->thread_count= thread_count;
2805 switch(enc->codec_type) {
2806 case CODEC_TYPE_AUDIO:
2807 for(j=0; j<opt_name_count; j++){
2809 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2810 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2811 av_set_double(enc, opt_names[j], d);
2813 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2814 audio_channels = enc->channels;
2815 audio_sample_rate = enc->sample_rate;
2817 ic->streams[i]->discard= AVDISCARD_ALL;
2819 case CODEC_TYPE_VIDEO:
2820 for(j=0; j<opt_name_count; j++){
2822 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2823 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2824 av_set_double(enc, opt_names[j], d);
2826 frame_height = enc->height;
2827 frame_width = enc->width;
2828 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2829 frame_pix_fmt = enc->pix_fmt;
2830 rfps = ic->streams[i]->r_frame_rate.num;
2831 rfps_base = ic->streams[i]->r_frame_rate.den;
2832 enc->workaround_bugs = workaround_bugs;
2833 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2835 enc->debug |= FF_DEBUG_MV;
2837 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2840 fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2841 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2843 (float)rfps / rfps_base, rfps, rfps_base);
2845 /* update the current frame rate to match the stream frame rate */
2847 frame_rate_base = rfps_base;
2849 enc->rate_emu = rate_emu;
2851 ic->streams[i]->discard= AVDISCARD_ALL;
2852 else if(video_discard)
2853 ic->streams[i]->discard= video_discard;
2855 case CODEC_TYPE_DATA:
2857 case CODEC_TYPE_SUBTITLE:
2859 case CODEC_TYPE_UNKNOWN:
2866 input_files[nb_input_files] = ic;
2867 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2868 /* dump the file content */
2870 dump_format(ic, nb_input_files, filename, 0);
2873 file_iformat = NULL;
2874 file_oformat = NULL;
2875 image_format = NULL;
2883 static void opt_grab(const char *arg)
2885 file_iformat = av_find_input_format(arg);
2889 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2891 int has_video, has_audio, i, j;
2892 AVFormatContext *ic;
2896 for(j=0;j<nb_input_files;j++) {
2897 ic = input_files[j];
2898 for(i=0;i<ic->nb_streams;i++) {
2899 AVCodecContext *enc = ic->streams[i]->codec;
2900 switch(enc->codec_type) {
2901 case CODEC_TYPE_AUDIO:
2904 case CODEC_TYPE_VIDEO:
2907 case CODEC_TYPE_DATA:
2908 case CODEC_TYPE_UNKNOWN:
2909 case CODEC_TYPE_SUBTITLE:
2916 *has_video_ptr = has_video;
2917 *has_audio_ptr = has_audio;
2920 static void new_video_stream(AVFormatContext *oc)
2923 AVCodecContext *video_enc;
2926 st = av_new_stream(oc, oc->nb_streams);
2928 fprintf(stderr, "Could not alloc stream\n");
2931 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2932 video_bitstream_filters= NULL;
2934 #if defined(HAVE_THREADS)
2936 avcodec_thread_init(st->codec, thread_count);
2939 video_enc = st->codec;
2942 video_enc->codec_tag= video_codec_tag;
2944 if( (video_global_header&1)
2945 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2946 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2947 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2949 if(video_global_header&2){
2950 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2951 avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2954 if (video_stream_copy) {
2955 st->stream_copy = 1;
2956 video_enc->codec_type = CODEC_TYPE_VIDEO;
2962 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2963 if (video_codec_id != CODEC_ID_NONE)
2964 codec_id = video_codec_id;
2966 video_enc->codec_id = codec_id;
2967 codec = avcodec_find_encoder(codec_id);
2969 for(i=0; i<opt_name_count; i++){
2971 double d= av_get_double(avctx_opts, opt_names[i], &opt);
2972 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2973 av_set_double(video_enc, opt_names[i], d);
2976 video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
2977 video_enc->time_base.den = frame_rate;
2978 video_enc->time_base.num = frame_rate_base;
2979 if(codec && codec->supported_framerates){
2980 const AVRational *p= codec->supported_framerates;
2981 AVRational req= (AVRational){frame_rate, frame_rate_base};
2982 const AVRational *best=NULL;
2983 AVRational best_error= (AVRational){INT_MAX, 1};
2984 for(; p->den!=0; p++){
2985 AVRational error= av_sub_q(req, *p);
2986 if(error.num <0) error.num *= -1;
2987 if(av_cmp_q(error, best_error) < 0){
2992 video_enc->time_base.den= best->num;
2993 video_enc->time_base.num= best->den;
2996 video_enc->width = frame_width + frame_padright + frame_padleft;
2997 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2998 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2999 video_enc->pix_fmt = frame_pix_fmt;
3001 if(codec && codec->pix_fmts){
3002 const enum PixelFormat *p= codec->pix_fmts;
3004 if(*p == video_enc->pix_fmt)
3008 video_enc->pix_fmt = codec->pix_fmts[0];
3012 video_enc->gop_size = 0;
3013 if (video_qscale || same_quality) {
3014 video_enc->flags |= CODEC_FLAG_QSCALE;
3015 video_enc->global_quality=
3016 st->quality = FF_QP2LAMBDA * video_qscale;
3020 video_enc->intra_matrix = intra_matrix;
3022 video_enc->inter_matrix = inter_matrix;
3025 video_enc->max_b_frames = b_frames;
3026 video_enc->b_quant_factor = 2.0;
3028 video_enc->qmin = video_qmin;
3029 video_enc->qmax = video_qmax;
3030 video_enc->lmin = video_lmin;
3031 video_enc->lmax = video_lmax;
3032 video_enc->rc_qsquish = video_qsquish;
3033 video_enc->mb_lmin = video_mb_lmin;
3034 video_enc->mb_lmax = video_mb_lmax;
3035 video_enc->max_qdiff = video_qdiff;
3036 video_enc->qcompress = video_qcomp;
3037 video_enc->rc_eq = video_rc_eq;
3038 video_enc->workaround_bugs = workaround_bugs;
3039 video_enc->thread_count = thread_count;
3040 p= video_rc_override_string;
3043 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3045 fprintf(stderr, "error parsing rc_override\n");
3048 video_enc->rc_override=
3049 av_realloc(video_enc->rc_override,
3050 sizeof(RcOverride)*(i+1));
3051 video_enc->rc_override[i].start_frame= start;
3052 video_enc->rc_override[i].end_frame = end;
3054 video_enc->rc_override[i].qscale= q;
3055 video_enc->rc_override[i].quality_factor= 1.0;
3058 video_enc->rc_override[i].qscale= 0;
3059 video_enc->rc_override[i].quality_factor= -q/100.0;
3064 video_enc->rc_override_count=i;
3066 video_enc->rc_buffer_size = video_rc_buffer_size;
3067 video_enc->rc_initial_buffer_occupancy = video_rc_buffer_size*3/4;
3068 video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
3069 video_enc->rc_initial_cplx= video_rc_initial_cplx;
3070 video_enc->i_quant_factor = video_i_qfactor;
3071 video_enc->b_quant_factor = video_b_qfactor;
3072 video_enc->i_quant_offset = video_i_qoffset;
3073 video_enc->b_quant_offset = video_b_qoffset;
3074 video_enc->me_threshold= me_threshold;
3075 video_enc->mb_threshold= mb_threshold;
3076 video_enc->intra_dc_precision= intra_dc_precision - 8;
3077 video_enc->strict_std_compliance = strict;
3078 video_enc->error_rate = error_rate;
3079 video_enc->scenechange_threshold= sc_threshold;
3080 video_enc->me_range = me_range;
3081 video_enc->me_penalty_compensation= me_penalty_compensation;
3082 video_enc->frame_skip_threshold= frame_skip_threshold;
3083 video_enc->frame_skip_factor= frame_skip_factor;
3084 video_enc->frame_skip_exp= frame_skip_exp;
3087 video_enc->rtp_mode= 1;
3088 video_enc->rtp_payload_size= packet_size;
3092 video_enc->flags|= CODEC_FLAG_PSNR;
3094 video_enc->me_method = me_method;
3099 video_enc->flags |= CODEC_FLAG_PASS1;
3101 video_enc->flags |= CODEC_FLAG_PASS2;
3106 /* reset some key parameters */
3108 video_codec_id = CODEC_ID_NONE;
3109 video_stream_copy = 0;
3112 static void new_audio_stream(AVFormatContext *oc)
3115 AVCodecContext *audio_enc;
3118 st = av_new_stream(oc, oc->nb_streams);
3120 fprintf(stderr, "Could not alloc stream\n");
3124 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3125 audio_bitstream_filters= NULL;
3127 #if defined(HAVE_THREADS)
3129 avcodec_thread_init(st->codec, thread_count);
3132 audio_enc = st->codec;
3133 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3136 audio_enc->codec_tag= audio_codec_tag;
3138 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3139 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3140 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
3142 if (audio_stream_copy) {
3143 st->stream_copy = 1;
3144 audio_enc->channels = audio_channels;
3146 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3148 for(i=0; i<opt_name_count; i++){
3150 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3151 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3152 av_set_double(audio_enc, opt_names[i], d);
3155 if (audio_codec_id != CODEC_ID_NONE)
3156 codec_id = audio_codec_id;
3157 audio_enc->codec_id = codec_id;
3159 audio_enc->bit_rate = audio_bit_rate;
3160 if (audio_qscale > QSCALE_NONE) {
3161 audio_enc->flags |= CODEC_FLAG_QSCALE;
3162 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3164 audio_enc->strict_std_compliance = strict;
3165 audio_enc->thread_count = thread_count;
3166 /* For audio codecs other than AC3 or DTS we limit */
3167 /* the number of coded channels to stereo */
3168 if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3169 && codec_id != CODEC_ID_DTS) {
3170 audio_enc->channels = 2;
3172 audio_enc->channels = audio_channels;
3174 audio_enc->sample_rate = audio_sample_rate;
3175 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3176 if (audio_language) {
3177 pstrcpy(st->language, sizeof(st->language), audio_language);
3178 av_free(audio_language);
3179 audio_language = NULL;
3182 /* reset some key parameters */
3184 audio_codec_id = CODEC_ID_NONE;
3185 audio_stream_copy = 0;
3188 static void opt_new_subtitle_stream(void)
3190 AVFormatContext *oc;
3192 AVCodecContext *subtitle_enc;
3195 if (nb_output_files <= 0) {
3196 fprintf(stderr, "At least one output file must be specified\n");
3199 oc = output_files[nb_output_files - 1];
3201 st = av_new_stream(oc, oc->nb_streams);
3203 fprintf(stderr, "Could not alloc stream\n");
3207 subtitle_enc = st->codec;
3208 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3209 if (subtitle_stream_copy) {
3210 st->stream_copy = 1;
3212 for(i=0; i<opt_name_count; i++){
3214 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3215 if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3216 av_set_double(subtitle_enc, opt_names[i], d);
3218 subtitle_enc->codec_id = subtitle_codec_id;
3221 if (subtitle_language) {
3222 pstrcpy(st->language, sizeof(st->language), subtitle_language);
3223 av_free(subtitle_language);
3224 subtitle_language = NULL;
3227 subtitle_codec_id = CODEC_ID_NONE;
3228 subtitle_stream_copy = 0;
3231 static void opt_new_audio_stream(void)
3233 AVFormatContext *oc;
3234 if (nb_output_files <= 0) {
3235 fprintf(stderr, "At least one output file must be specified\n");
3238 oc = output_files[nb_output_files - 1];
3239 new_audio_stream(oc);
3242 static void opt_new_video_stream(void)
3244 AVFormatContext *oc;
3245 if (nb_output_files <= 0) {
3246 fprintf(stderr, "At least one output file must be specified\n");
3249 oc = output_files[nb_output_files - 1];
3250 new_video_stream(oc);
3253 static void opt_output_file(const char *filename)
3255 AVFormatContext *oc;
3256 int use_video, use_audio, input_has_video, input_has_audio, i;
3257 AVFormatParameters params, *ap = ¶ms;
3259 if (!strcmp(filename, "-"))
3262 oc = av_alloc_format_context();
3264 if (!file_oformat) {
3265 file_oformat = guess_format(NULL, filename, NULL);
3266 if (!file_oformat) {
3267 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3273 oc->oformat = file_oformat;
3274 pstrcpy(oc->filename, sizeof(oc->filename), filename);
3276 if (!strcmp(file_oformat->name, "ffm") &&
3277 strstart(filename, "http:", NULL)) {
3278 /* special case for files sent to ffserver: we get the stream
3279 parameters from ffserver */
3280 if (read_ffserver_streams(oc, filename) < 0) {
3281 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3285 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3286 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3288 /* disable if no corresponding type found and at least one
3290 if (nb_input_files > 0) {
3291 check_audio_video_inputs(&input_has_video, &input_has_audio);
3292 if (!input_has_video)
3294 if (!input_has_audio)
3298 /* manual disable */
3299 if (audio_disable) {
3302 if (video_disable) {
3307 new_video_stream(oc);
3311 new_audio_stream(oc);
3314 if (!oc->nb_streams) {
3315 fprintf(stderr, "No audio or video streams available\n");
3319 oc->timestamp = rec_timestamp;
3322 pstrcpy(oc->title, sizeof(oc->title), str_title);
3324 pstrcpy(oc->author, sizeof(oc->author), str_author);
3326 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3328 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3330 pstrcpy(oc->album, sizeof(oc->album), str_album);
3333 output_files[nb_output_files++] = oc;
3335 /* check filename in case of an image number is expected */
3336 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3337 if (!av_filename_number_test(oc->filename)) {
3338 print_error(oc->filename, AVERROR_NUMEXPECTED);
3343 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3344 /* test if it already exists to avoid loosing precious files */
3345 if (!file_overwrite &&
3346 (strchr(filename, ':') == NULL ||
3347 strstart(filename, "file:", NULL))) {
3348 if (url_exist(filename)) {
3351 if ( !using_stdin ) {
3352 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3355 if (toupper(c) != 'Y') {
3356 fprintf(stderr, "Not overwriting - exiting\n");
3361 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3368 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3369 fprintf(stderr, "Could not open '%s'\n", filename);
3374 memset(ap, 0, sizeof(*ap));
3375 ap->image_format = image_format;
3376 if (av_set_parameters(oc, ap) < 0) {
3377 fprintf(stderr, "%s: Invalid encoding parameters\n",
3382 oc->packet_size= mux_packet_size;
3383 oc->mux_rate= mux_rate;
3384 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3385 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3386 oc->loop_output = loop_output;
3388 for(i=0; i<opt_name_count; i++){
3390 double d = av_get_double(avformat_opts, opt_names[i], &opt);
3391 if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3392 av_set_double(oc, opt_names[i], d);
3395 /* reset some options */
3396 file_oformat = NULL;
3397 file_iformat = NULL;
3398 image_format = NULL;
3401 /* prepare dummy protocols for grab */
3402 static void prepare_grab(void)
3404 int has_video, has_audio, i, j;
3405 AVFormatContext *oc;
3406 AVFormatContext *ic;
3407 AVFormatParameters vp1, *vp = &vp1;
3408 AVFormatParameters ap1, *ap = &ap1;
3410 /* see if audio/video inputs are needed */
3413 memset(ap, 0, sizeof(*ap));
3414 memset(vp, 0, sizeof(*vp));
3415 vp->time_base.num= 1;
3416 for(j=0;j<nb_output_files;j++) {
3417 oc = output_files[j];
3418 for(i=0;i<oc->nb_streams;i++) {
3419 AVCodecContext *enc = oc->streams[i]->codec;
3420 switch(enc->codec_type) {
3421 case CODEC_TYPE_AUDIO:
3422 if (enc->sample_rate > ap->sample_rate)
3423 ap->sample_rate = enc->sample_rate;
3424 if (enc->channels > ap->channels)
3425 ap->channels = enc->channels;
3428 case CODEC_TYPE_VIDEO:
3429 if (enc->width > vp->width)
3430 vp->width = enc->width;
3431 if (enc->height > vp->height)
3432 vp->height = enc->height;
3434 if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3435 vp->time_base = enc->time_base;
3436 vp->width += frame_leftBand + frame_rightBand;
3437 vp->width -= (frame_padleft + frame_padright);
3438 vp->height += frame_topBand + frame_bottomBand;
3439 vp->height -= (frame_padtop + frame_padbottom);
3449 if (has_video == 0 && has_audio == 0) {
3450 fprintf(stderr, "Output file must have at least one audio or video stream\n");
3455 AVInputFormat *fmt1;
3456 fmt1 = av_find_input_format(video_grab_format);
3457 vp->device = video_device;
3458 vp->channel = video_channel;
3459 vp->standard = video_standard;
3460 vp->pix_fmt = frame_pix_fmt;
3461 if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3462 fprintf(stderr, "Could not find video grab device\n");
3465 /* If not enough info to get the stream parameters, we decode the
3466 first frames to get it. */
3467 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3468 fprintf(stderr, "Could not find video grab parameters\n");
3471 /* by now video grab has one stream */
3472 ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3473 ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3474 input_files[nb_input_files] = ic;
3477 dump_format(ic, nb_input_files, "", 0);
3481 if (has_audio && audio_grab_format) {
3482 AVInputFormat *fmt1;
3483 fmt1 = av_find_input_format(audio_grab_format);
3484 ap->device = audio_device;
3485 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3486 fprintf(stderr, "Could not find audio grab device\n");
3489 input_files[nb_input_files] = ic;
3492 dump_format(ic, nb_input_files, "", 0);
3498 /* same option as mencoder */
3499 static void opt_pass(const char *pass_str)
3502 pass = atoi(pass_str);
3503 if (pass != 1 && pass != 2) {
3504 fprintf(stderr, "pass number can be only 1 or 2\n");
3510 #if defined(__MINGW32__) || defined(CONFIG_OS2)
3511 static int64_t getutime(void)
3513 return av_gettime();
3516 static int64_t getutime(void)
3518 struct rusage rusage;
3520 getrusage(RUSAGE_SELF, &rusage);
3521 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3525 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3526 extern int ffm_nopts;
3529 static void show_formats(void)
3531 AVInputFormat *ifmt;
3532 AVOutputFormat *ofmt;
3533 AVImageFormat *image_fmt;
3536 const char **pp, *last_name;
3538 printf("File formats:\n");
3543 const char *name=NULL;
3544 const char *long_name=NULL;
3546 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3547 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3548 strcmp(ofmt->name, last_name)>0){
3550 long_name= ofmt->long_name;
3554 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3555 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3556 strcmp(ifmt->name, last_name)>0){
3558 long_name= ifmt->long_name;
3561 if(name && strcmp(ifmt->name, name)==0)
3573 long_name ? long_name:" ");
3577 printf("Image formats (filename extensions, if any, follow):\n");
3578 for(image_fmt = first_image_format; image_fmt != NULL;
3579 image_fmt = image_fmt->next) {
3582 image_fmt->img_read ? "D":" ",
3583 image_fmt->img_write ? "E":" ",
3585 image_fmt->extensions ? image_fmt->extensions:" ");
3589 printf("Codecs:\n");
3595 const char *type_str;
3598 for(p = first_avcodec; p != NULL; p = p->next) {
3599 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3600 strcmp(p->name, last_name)>0){
3602 decode= encode= cap=0;
3604 if(p2 && strcmp(p->name, p2->name)==0){
3605 if(p->decode) decode=1;
3606 if(p->encode) encode=1;
3607 cap |= p->capabilities;
3612 last_name= p2->name;
3615 case CODEC_TYPE_VIDEO:
3618 case CODEC_TYPE_AUDIO:
3621 case CODEC_TYPE_SUBTITLE:
3630 decode ? "D": (/*p2->decoder ? "d":*/" "),
3633 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3634 cap & CODEC_CAP_DR1 ? "D":" ",
3635 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3637 /* if(p2->decoder && decode==0)
3638 printf(" use %s for decoding", p2->decoder->name);*/
3643 printf("Supported file protocols:\n");
3644 for(up = first_protocol; up != NULL; up = up->next)
3645 printf(" %s:", up->name);
3648 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3649 printf("Motion estimation methods:\n");
3653 if ((pp - motion_str + 1) == ME_ZERO)
3654 printf("(fastest)");
3655 else if ((pp - motion_str + 1) == ME_FULL)
3656 printf("(slowest)");
3657 else if ((pp - motion_str + 1) == ME_EPZS)
3658 printf("(default)");
3663 "Note, the names of encoders and decoders dont always match, so there are\n"
3664 "several cases where the above table shows encoder only or decoder only entries\n"
3665 "even though both encoding and decoding are supported for example, the h263\n"
3666 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3671 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3674 const char *p = str;
3681 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3688 static void opt_inter_matrix(const char *arg)
3690 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3691 parse_matrix_coeffs(inter_matrix, arg);
3694 static void opt_intra_matrix(const char *arg)
3696 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3697 parse_matrix_coeffs(intra_matrix, arg);
3700 static void opt_target(const char *arg)
3703 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3705 if(!strncmp(arg, "pal-", 4)) {
3708 } else if(!strncmp(arg, "ntsc-", 5)) {
3711 } else if(!strncmp(arg, "film-", 5)) {
3716 /* Calculate FR via float to avoid int overflow */
3717 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3720 } else if((fr == 29970) || (fr == 23976)) {
3723 /* Try to determine PAL/NTSC by peeking in the input files */
3724 if(nb_input_files) {
3726 for(j = 0; j < nb_input_files; j++) {
3727 for(i = 0; i < input_files[j]->nb_streams; i++) {
3728 AVCodecContext *c = input_files[j]->streams[i]->codec;
3729 if(c->codec_type != CODEC_TYPE_VIDEO)
3731 fr = c->time_base.den * 1000 / c->time_base.num;
3735 } else if((fr == 29970) || (fr == 23976)) {