3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 #define HAVE_AV_CONFIG_H
23 #include "framehook.h"
30 #include <sys/ioctl.h>
33 #include <sys/resource.h>
37 #include <sys/types.h>
38 #include <sys/select.h>
41 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
50 #if !defined(INFINITY) && defined(HUGE_VAL)
51 #define INFINITY HUGE_VAL
54 /* select an input stream for an output stream */
55 typedef struct AVStreamMap {
59 int sync_stream_index;
62 /** select an input file for an output file */
63 typedef struct AVMetaDataMap {
68 extern const OptionDef options[];
70 static void show_help(void);
71 static void show_license(void);
72 static int opt_default(const char *opt, const char *arg);
76 static AVFormatContext *input_files[MAX_FILES];
77 static int64_t input_files_ts_offset[MAX_FILES];
78 static int nb_input_files = 0;
80 static AVFormatContext *output_files[MAX_FILES];
81 static int nb_output_files = 0;
83 static AVStreamMap stream_maps[MAX_FILES];
84 static int nb_stream_maps;
86 static AVMetaDataMap meta_data_maps[MAX_FILES];
87 static int nb_meta_data_maps;
89 static AVInputFormat *file_iformat;
90 static AVOutputFormat *file_oformat;
91 static AVImageFormat *image_format;
92 static int frame_width = 0;
93 static int frame_height = 0;
94 static float frame_aspect_ratio = 0;
95 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
96 static int frame_padtop = 0;
97 static int frame_padbottom = 0;
98 static int frame_padleft = 0;
99 static int frame_padright = 0;
100 static int padcolor[3] = {16,128,128}; /* default to black */
101 static int frame_topBand = 0;
102 static int frame_bottomBand = 0;
103 static int frame_leftBand = 0;
104 static int frame_rightBand = 0;
105 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
106 static int frame_rate = 25;
107 static int frame_rate_base = 1;
108 static float video_qscale = 0;
109 static int video_lmin = 2*FF_QP2LAMBDA;
110 static int video_lmax = 31*FF_QP2LAMBDA;
111 static int video_mb_lmin = 2*FF_QP2LAMBDA;
112 static int video_mb_lmax = 31*FF_QP2LAMBDA;
113 static int video_qdiff = 3;
114 static uint16_t *intra_matrix = NULL;
115 static uint16_t *inter_matrix = NULL;
116 #if 0 //experimental, (can be removed)
117 static float video_rc_qsquish=1.0;
118 static float video_rc_qmod_amp=0;
119 static int video_rc_qmod_freq=0;
121 static char *video_rc_override_string=NULL;
122 static char *video_rc_eq="tex^qComp";
123 static float video_rc_buffer_aggressivity=1.0;
124 static int me_method = ME_EPZS;
125 static int video_disable = 0;
126 static int video_discard = 0;
127 static int video_codec_id = CODEC_ID_NONE;
128 static int video_codec_tag = 0;
129 static int same_quality = 0;
130 static int do_deinterlace = 0;
131 static int packet_size = 0;
132 static int error_rate = 0;
133 static int strict = 0;
134 static int top_field_first = -1;
135 static int sc_threshold = 0;
136 static int me_threshold = 0;
137 static int mb_threshold = 0;
138 static int intra_dc_precision = 8;
139 static int me_penalty_compensation= 256;
140 static int frame_skip_threshold= 0;
141 static int frame_skip_factor= 0;
142 static int frame_skip_exp= 0;
143 static int loop_input = 0;
144 static int loop_output = AVFMT_NOOUTPUTLOOP;
145 static int qp_hist = 0;
147 static int intra_only = 0;
148 static int audio_sample_rate = 44100;
149 static int audio_bit_rate = 64000;
150 #define QSCALE_NONE -99999
151 static float audio_qscale = QSCALE_NONE;
152 static int audio_disable = 0;
153 static int audio_channels = 1;
154 static int audio_codec_id = CODEC_ID_NONE;
155 static int audio_codec_tag = 0;
156 static char *audio_language = NULL;
158 static int subtitle_codec_id = CODEC_ID_NONE;
159 static char *subtitle_language = NULL;
161 static float mux_preload= 0.5;
162 static float mux_max_delay= 0.7;
164 static int64_t recording_time = 0;
165 static int64_t start_time = 0;
166 static int64_t rec_timestamp = 0;
167 static int64_t input_ts_offset = 0;
168 static int file_overwrite = 0;
169 static char *str_title = NULL;
170 static char *str_author = NULL;
171 static char *str_copyright = NULL;
172 static char *str_comment = NULL;
173 static char *str_album = NULL;
174 static int do_benchmark = 0;
175 static int do_hex_dump = 0;
176 static int do_pkt_dump = 0;
177 static int do_psnr = 0;
178 static int do_vstats = 0;
179 static int do_pass = 0;
180 static char *pass_logfilename = NULL;
181 static int audio_stream_copy = 0;
182 static int video_stream_copy = 0;
183 static int subtitle_stream_copy = 0;
184 static int video_sync_method= 1;
185 static int audio_sync_method= 0;
186 static int copy_ts= 0;
187 static int opt_shortest = 0; //
188 static int video_global_header = 0;
190 static int rate_emu = 0;
193 static const char *video_grab_format = "bktr";
195 #ifdef CONFIG_VIDEO4LINUX2
196 static const char *video_grab_format = "video4linux2";
198 static const char *video_grab_format = "video4linux";
201 static char *video_device = NULL;
202 static char *grab_device = NULL;
203 static int video_channel = 0;
204 static char *video_standard = "ntsc";
206 static const char *audio_grab_format = "audio_device";
207 static char *audio_device = NULL;
208 static int audio_volume = 256;
210 static int using_stdin = 0;
211 static int using_vhook = 0;
212 static int verbose = 1;
213 static int thread_count= 1;
214 static int q_pressed = 0;
215 static int64_t video_size = 0;
216 static int64_t audio_size = 0;
217 static int64_t extra_size = 0;
218 static int nb_frames_dup = 0;
219 static int nb_frames_drop = 0;
220 static int input_sync;
221 static int limit_filesize = 0; //
223 static int pgmyuv_compatibility_hack=0;
224 static int dts_delta_threshold = 10;
226 static int sws_flags = SWS_BICUBIC;
228 const char **opt_names=NULL;
229 int opt_name_count=0;
230 AVCodecContext *avctx_opts;
231 AVFormatContext *avformat_opts;
233 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
234 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
235 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
237 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
239 struct AVInputStream;
241 typedef struct AVOutputStream {
242 int file_index; /* file index */
243 int index; /* stream index in the output file */
244 int source_index; /* AVInputStream index */
245 AVStream *st; /* stream in the output file */
246 int encoding_needed; /* true if encoding needed for this stream */
248 /* input pts and corresponding output pts
250 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
251 struct AVInputStream *sync_ist; /* input stream to sync against */
252 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
255 AVFrame pict_tmp; /* temporary image for resampling */
256 struct SwsContext *img_resample_ctx; /* for image resampling */
260 int topBand; /* cropping area sizes */
264 int padtop; /* padding area sizes */
271 ReSampleContext *resample; /* for audio resampling */
272 FifoBuffer fifo; /* for compression: one audio fifo per codec */
276 typedef struct AVInputStream {
280 int discard; /* true if stream data should be discarded */
281 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
282 int64_t sample_index; /* current sample */
284 int64_t start; /* time when read started */
285 unsigned long frame; /* current frame */
286 int64_t next_pts; /* synthetic pts for cases where pkt.pts
288 int64_t pts; /* current pts */
289 int is_start; /* is 1 at the start and after a discontinuity */
292 typedef struct AVInputFile {
293 int eof_reached; /* true if eof reached */
294 int ist_index; /* index of first stream in ist_table */
295 int buffer_size; /* current total buffer size */
296 int buffer_size_max; /* buffer size at which we consider we can stop
298 int nb_streams; /* nb streams we are aware of */
303 /* init terminal so that we can grab keys */
304 static struct termios oldtty;
306 static void term_exit(void)
308 tcsetattr (0, TCSANOW, &oldtty);
311 static volatile sig_atomic_t received_sigterm = 0;
314 sigterm_handler(int sig)
316 received_sigterm = sig;
320 static void term_init(void)
327 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
328 |INLCR|IGNCR|ICRNL|IXON);
329 tty.c_oflag |= OPOST;
330 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
331 tty.c_cflag &= ~(CSIZE|PARENB);
336 tcsetattr (0, TCSANOW, &tty);
338 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
339 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
340 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
342 register a function to be called at normal program termination
345 #ifdef CONFIG_BEOS_NETSERVER
346 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
350 /* read a key without blocking */
351 static int read_key(void)
355 #ifndef CONFIG_BEOS_NETSERVER
363 n = select(1, &rfds, NULL, NULL, &tv);
375 static int decode_interrupt_cb(void)
377 return q_pressed || (q_pressed = read_key() == 'q');
382 static volatile int received_sigterm = 0;
384 /* no interactive support */
385 static void term_exit(void)
389 static void term_init(void)
393 static int read_key(void)
400 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
405 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
408 /* copy stream format */
409 s->nb_streams = ic->nb_streams;
410 for(i=0;i<ic->nb_streams;i++) {
413 // FIXME: a more elegant solution is needed
414 st = av_mallocz(sizeof(AVStream));
415 memcpy(st, ic->streams[i], sizeof(AVStream));
416 st->codec = avcodec_alloc_context();
417 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
421 av_close_input_file(ic);
426 get_sync_ipts(const AVOutputStream *ost)
428 const AVInputStream *ist = ost->sync_ist;
429 return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
432 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
434 AVPacket new_pkt= *pkt;
435 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
436 &new_pkt.data, &new_pkt.size,
437 pkt->data, pkt->size,
438 pkt->flags & PKT_FLAG_KEY);
441 new_pkt.destruct= av_destruct_packet;
448 av_interleaved_write_frame(s, pkt);
451 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
453 static void do_audio_out(AVFormatContext *s,
456 unsigned char *buf, int size)
459 static uint8_t *audio_buf = NULL;
460 static uint8_t *audio_out = NULL;
461 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
463 int size_out, frame_bytes, ret;
464 AVCodecContext *enc= ost->st->codec;
466 /* SC: dynamic allocation of buffers */
468 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
470 audio_out = av_malloc(audio_out_size);
471 if (!audio_buf || !audio_out)
472 return; /* Should signal an error ! */
474 if(audio_sync_method){
475 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
476 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2);
477 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
478 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
480 //FIXME resample delay
481 if(fabs(delta) > 50){
484 byte_delta= FFMAX(byte_delta, -size);
488 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
493 static uint8_t *input_tmp= NULL;
494 input_tmp= av_realloc(input_tmp, byte_delta + size);
496 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
499 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
501 memset(input_tmp, 0, byte_delta);
502 memcpy(input_tmp + byte_delta, buf, size);
506 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
508 }else if(audio_sync_method>1){
509 int comp= clip(delta, -audio_sync_method, audio_sync_method);
510 assert(ost->audio_resample);
512 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
513 // 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));
514 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
518 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
519 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2); //FIXME wrong
521 if (ost->audio_resample) {
523 size_out = audio_resample(ost->resample,
524 (short *)buftmp, (short *)buf,
525 size / (ist->st->codec->channels * 2));
526 size_out = size_out * enc->channels * 2;
532 /* now encode as many frames as possible */
533 if (enc->frame_size > 1) {
534 /* output resampled raw samples */
535 fifo_write(&ost->fifo, buftmp, size_out,
538 frame_bytes = enc->frame_size * 2 * enc->channels;
540 while (fifo_read(&ost->fifo, audio_buf, frame_bytes,
541 &ost->fifo.rptr) == 0) {
543 av_init_packet(&pkt);
545 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
548 pkt.stream_index= ost->index;
551 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
552 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
553 pkt.flags |= PKT_FLAG_KEY;
554 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
556 ost->sync_opts += enc->frame_size;
560 av_init_packet(&pkt);
562 ost->sync_opts += size_out / (2 * enc->channels);
564 /* output a pcm frame */
565 /* XXX: change encoding codec API to avoid this ? */
566 switch(enc->codec->id) {
567 case CODEC_ID_PCM_S32LE:
568 case CODEC_ID_PCM_S32BE:
569 case CODEC_ID_PCM_U32LE:
570 case CODEC_ID_PCM_U32BE:
571 size_out = size_out << 1;
573 case CODEC_ID_PCM_S24LE:
574 case CODEC_ID_PCM_S24BE:
575 case CODEC_ID_PCM_U24LE:
576 case CODEC_ID_PCM_U24BE:
577 case CODEC_ID_PCM_S24DAUD:
578 size_out = size_out / 2 * 3;
580 case CODEC_ID_PCM_S16LE:
581 case CODEC_ID_PCM_S16BE:
582 case CODEC_ID_PCM_U16LE:
583 case CODEC_ID_PCM_U16BE:
586 size_out = size_out >> 1;
589 ret = avcodec_encode_audio(enc, audio_out, size_out,
592 pkt.stream_index= ost->index;
595 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
596 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
597 pkt.flags |= PKT_FLAG_KEY;
598 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
602 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
606 AVPicture picture_tmp;
609 dec = ist->st->codec;
611 /* deinterlace : must be done before any resize */
612 if (do_deinterlace || using_vhook) {
615 /* create temporary picture */
616 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
617 buf = av_malloc(size);
621 picture2 = &picture_tmp;
622 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
625 if(avpicture_deinterlace(picture2, picture,
626 dec->pix_fmt, dec->width, dec->height) < 0) {
627 /* if error, do not deinterlace */
633 img_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
639 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
641 if (picture != picture2)
642 *picture = *picture2;
646 /* we begin to correct av delay at this threshold */
647 #define AV_DELAY_MAX 0.100
649 static void do_subtitle_out(AVFormatContext *s,
655 static uint8_t *subtitle_out = NULL;
656 int subtitle_out_max_size = 65536;
657 int subtitle_out_size, nb, i;
661 if (pts == AV_NOPTS_VALUE) {
662 fprintf(stderr, "Subtitle packets must have a pts\n");
666 enc = ost->st->codec;
669 subtitle_out = av_malloc(subtitle_out_max_size);
672 /* Note: DVB subtitle need one packet to draw them and one other
673 packet to clear them */
674 /* XXX: signal it in the codec context ? */
675 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
680 for(i = 0; i < nb; i++) {
681 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
682 subtitle_out_max_size, sub);
684 av_init_packet(&pkt);
685 pkt.stream_index = ost->index;
686 pkt.data = subtitle_out;
687 pkt.size = subtitle_out_size;
688 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);
689 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
690 /* XXX: the pts correction is handled here. Maybe handling
691 it in the codec would be better */
693 pkt.pts += 90 * sub->start_display_time;
695 pkt.pts += 90 * sub->end_display_time;
697 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
701 static int bit_buffer_size= 1024*256;
702 static uint8_t *bit_buffer= NULL;
704 static void do_video_out(AVFormatContext *s,
710 int nb_frames, i, ret;
711 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
712 AVFrame picture_crop_temp, picture_pad_temp;
713 uint8_t *buf = NULL, *buf1 = NULL;
714 AVCodecContext *enc, *dec;
716 avcodec_get_frame_defaults(&picture_crop_temp);
717 avcodec_get_frame_defaults(&picture_pad_temp);
719 enc = ost->st->codec;
720 dec = ist->st->codec;
722 /* by default, we output a single frame */
727 if(video_sync_method){
729 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
730 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
733 else if (vdelta > 1.1)
734 nb_frames = lrintf(vdelta);
735 //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);
739 fprintf(stderr, "*** drop!\n");
740 }else if (nb_frames > 1) {
741 nb_frames_dup += nb_frames;
743 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
746 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
748 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
752 if (ost->video_crop) {
753 if (img_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
754 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
757 formatted_picture = &picture_crop_temp;
759 formatted_picture = in_picture;
762 final_picture = formatted_picture;
763 padding_src = formatted_picture;
764 resampling_dst = &ost->pict_tmp;
765 if (ost->video_pad) {
766 final_picture = &ost->pict_tmp;
767 if (ost->video_resample) {
768 if (img_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
769 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
772 resampling_dst = &picture_pad_temp;
776 if (ost->video_resample) {
778 final_picture = &ost->pict_tmp;
779 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
780 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
783 if (ost->video_pad) {
784 img_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
785 enc->height, enc->width, enc->pix_fmt,
786 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
789 /* duplicates frame if needed */
790 for(i=0;i<nb_frames;i++) {
792 av_init_packet(&pkt);
793 pkt.stream_index= ost->index;
795 if (s->oformat->flags & AVFMT_RAWPICTURE) {
796 /* raw pictures are written as AVPicture structure to
797 avoid any copies. We support temorarily the older
799 AVFrame* old_frame = enc->coded_frame;
800 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
801 pkt.data= (uint8_t *)final_picture;
802 pkt.size= sizeof(AVPicture);
803 if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
804 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
805 if(dec->coded_frame && dec->coded_frame->key_frame)
806 pkt.flags |= PKT_FLAG_KEY;
808 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
809 enc->coded_frame = old_frame;
813 big_picture= *final_picture;
814 /* better than nothing: use input picture interlaced
816 big_picture.interlaced_frame = in_picture->interlaced_frame;
817 if(avctx_opts->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
818 if(top_field_first == -1)
819 big_picture.top_field_first = in_picture->top_field_first;
821 big_picture.top_field_first = top_field_first;
824 /* handles sameq here. This is not correct because it may
825 not be a global option */
827 big_picture.quality = ist->st->quality;
829 big_picture.quality = ost->st->quality;
831 big_picture.pict_type = 0;
832 // big_picture.pts = AV_NOPTS_VALUE;
833 big_picture.pts= ost->sync_opts;
834 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
835 //av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
836 ret = avcodec_encode_video(enc,
837 bit_buffer, bit_buffer_size,
839 //enc->frame_number = enc->real_pict_num;
841 pkt.data= bit_buffer;
843 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
844 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
845 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n",
846 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
847 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
849 if(enc->coded_frame && enc->coded_frame->key_frame)
850 pkt.flags |= PKT_FLAG_KEY;
851 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
853 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
854 // enc->frame_number-1, enc->real_pict_num, ret,
856 /* if two pass, output log */
857 if (ost->logfile && enc->stats_out) {
858 fprintf(ost->logfile, "%s", enc->stats_out);
870 static double psnr(double d){
871 if(d==0) return INFINITY;
872 return -10.0*log(d)/log(10.0);
875 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
878 static FILE *fvstats=NULL;
885 double ti1, bitrate, avg_bitrate;
889 today = localtime(&today2);
890 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
893 fvstats = fopen(filename,"w");
901 enc = ost->st->codec;
902 if (enc->codec_type == CODEC_TYPE_VIDEO) {
903 frame_number = ost->frame_number;
904 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
905 if (enc->flags&CODEC_FLAG_PSNR)
906 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
908 fprintf(fvstats,"f_size= %6d ", frame_size);
909 /* compute pts value */
910 ti1 = ost->sync_opts * av_q2d(enc->time_base);
914 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
915 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
916 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
917 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
918 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
922 static void print_report(AVFormatContext **output_files,
923 AVOutputStream **ost_table, int nb_ostreams,
928 AVFormatContext *oc, *os;
931 int frame_number, vid, i;
932 double bitrate, ti1, pts;
933 static int64_t last_time = -1;
934 static int qp_histogram[52];
936 if (!is_last_report) {
938 /* display the report every 0.5 seconds */
939 cur_time = av_gettime();
940 if (last_time == -1) {
941 last_time = cur_time;
944 if ((cur_time - last_time) < 500000)
946 last_time = cur_time;
950 oc = output_files[0];
952 total_size = url_ftell(&oc->pb);
957 for(i=0;i<nb_ostreams;i++) {
959 os = output_files[ost->file_index];
960 enc = ost->st->codec;
961 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
962 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
963 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
965 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
966 frame_number = ost->frame_number;
967 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%3.1f ",
968 frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
970 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
971 if(qp_hist && enc->coded_frame){
973 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
974 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
977 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
979 if (enc->flags&CODEC_FLAG_PSNR){
981 double error, error_sum=0;
982 double scale, scale_sum=0;
983 char type[3]= {'Y','U','V'};
984 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
987 error= enc->error[j];
988 scale= enc->width*enc->height*255.0*255.0*frame_number;
990 error= enc->coded_frame->error[j];
991 scale= enc->width*enc->height*255.0*255.0;
996 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
998 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1002 /* compute min output value */
1003 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1004 if ((pts < ti1) && (pts > 0))
1010 if (verbose || is_last_report) {
1011 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1013 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1014 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1015 (double)total_size / 1024, ti1, bitrate);
1018 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1019 nb_frames_dup, nb_frames_drop);
1022 fprintf(stderr, "%s \r", buf);
1027 if (is_last_report && verbose >= 0){
1028 int64_t raw= audio_size + video_size + extra_size;
1029 fprintf(stderr, "\n");
1030 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1034 100.0*(total_size - raw)/raw
1039 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1040 static int output_packet(AVInputStream *ist, int ist_index,
1041 AVOutputStream **ost_table, int nb_ostreams,
1042 const AVPacket *pkt)
1044 AVFormatContext *os;
1045 AVOutputStream *ost;
1049 int data_size, got_picture;
1051 void *buffer_to_free;
1052 static unsigned int samples_size= 0;
1053 static short *samples= NULL;
1054 AVSubtitle subtitle, *subtitle_to_free;
1058 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1059 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1060 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1062 // assert(ist->pts == ist->next_pts);
1076 /* decode the packet if needed */
1077 data_buf = NULL; /* fail safe */
1079 subtitle_to_free = NULL;
1080 if (ist->decoding_needed) {
1081 switch(ist->st->codec->codec_type) {
1082 case CODEC_TYPE_AUDIO:{
1084 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1085 /* XXX: could avoid copy if PCM 16 bits with same
1086 endianness as CPU */
1087 ret = avcodec_decode_audio(ist->st->codec, samples, &data_size,
1093 /* Some bug in mpeg audio decoder gives */
1094 /* data_size < 0, it seems they are overflows */
1095 if (data_size <= 0) {
1096 /* no audio frame */
1099 data_buf = (uint8_t *)samples;
1100 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1101 (ist->st->codec->sample_rate * ist->st->codec->channels);
1103 case CODEC_TYPE_VIDEO:
1104 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1105 /* XXX: allocate picture correctly */
1106 avcodec_get_frame_defaults(&picture);
1108 ret = avcodec_decode_video(ist->st->codec,
1109 &picture, &got_picture, ptr, len);
1110 ist->st->quality= picture.quality;
1114 /* no picture yet */
1115 goto discard_packet;
1117 if (ist->st->codec->time_base.num != 0) {
1118 ist->next_pts += ((int64_t)AV_TIME_BASE *
1119 ist->st->codec->time_base.num) /
1120 ist->st->codec->time_base.den;
1124 case CODEC_TYPE_SUBTITLE:
1125 ret = avcodec_decode_subtitle(ist->st->codec,
1126 &subtitle, &got_subtitle, ptr, len);
1129 if (!got_subtitle) {
1130 goto discard_packet;
1132 subtitle_to_free = &subtitle;
1139 switch(ist->st->codec->codec_type) {
1140 case CODEC_TYPE_AUDIO:
1141 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1142 (ist->st->codec->sample_rate * ist->st->codec->channels);
1144 case CODEC_TYPE_VIDEO:
1145 if (ist->st->codec->time_base.num != 0) {
1146 ist->next_pts += ((int64_t)AV_TIME_BASE *
1147 ist->st->codec->time_base.num) /
1148 ist->st->codec->time_base.den;
1158 buffer_to_free = NULL;
1159 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1160 pre_process_video_frame(ist, (AVPicture *)&picture,
1164 // preprocess audio (volume)
1165 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1166 if (audio_volume != 256) {
1169 for(i=0;i<(data_size / sizeof(short));i++) {
1170 int v = ((*volp) * audio_volume + 128) >> 8;
1171 if (v < -32768) v = -32768;
1172 if (v > 32767) v = 32767;
1178 /* frame rate emulation */
1179 if (ist->st->codec->rate_emu) {
1180 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1181 int64_t now = av_gettime() - ist->start;
1189 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1190 is the one of the next displayed one */
1191 /* XXX: add mpeg4 too ? */
1192 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1193 if (ist->st->codec->pict_type != B_TYPE) {
1195 tmp = ist->last_ip_pts;
1196 ist->last_ip_pts = ist->frac_pts.val;
1197 ist->frac_pts.val = tmp;
1201 /* if output time reached then transcode raw format,
1202 encode packets and output them */
1203 if (start_time == 0 || ist->pts >= start_time)
1204 for(i=0;i<nb_ostreams;i++) {
1208 if (ost->source_index == ist_index) {
1209 os = output_files[ost->file_index];
1212 printf("%d: got pts=%0.3f %0.3f\n", i,
1213 (double)pkt->pts / AV_TIME_BASE,
1214 ((double)ist->pts / AV_TIME_BASE) -
1215 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1217 /* set the input output pts pairs */
1218 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1220 if (ost->encoding_needed) {
1221 switch(ost->st->codec->codec_type) {
1222 case CODEC_TYPE_AUDIO:
1223 do_audio_out(os, ost, ist, data_buf, data_size);
1225 case CODEC_TYPE_VIDEO:
1226 do_video_out(os, ost, ist, &picture, &frame_size);
1227 video_size += frame_size;
1228 if (do_vstats && frame_size)
1229 do_video_stats(os, ost, frame_size);
1231 case CODEC_TYPE_SUBTITLE:
1232 do_subtitle_out(os, ost, ist, &subtitle,
1239 AVFrame avframe; //FIXME/XXX remove this
1241 av_init_packet(&opkt);
1243 /* no reencoding needed : output the packet directly */
1244 /* force the input stream PTS */
1246 avcodec_get_frame_defaults(&avframe);
1247 ost->st->codec->coded_frame= &avframe;
1248 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1250 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1251 audio_size += data_size;
1252 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1253 video_size += data_size;
1257 opkt.stream_index= ost->index;
1258 if(pkt->pts != AV_NOPTS_VALUE)
1259 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);
1261 opkt.pts= AV_NOPTS_VALUE;
1265 if (pkt->dts == AV_NOPTS_VALUE)
1266 dts = ist->next_pts;
1268 dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1269 opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
1271 opkt.flags= pkt->flags;
1273 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1274 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1275 opkt.destruct= av_destruct_packet;
1277 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1278 ost->st->codec->frame_number++;
1279 ost->frame_number++;
1280 av_free_packet(&opkt);
1284 av_free(buffer_to_free);
1285 /* XXX: allocate the subtitles in the codec ? */
1286 if (subtitle_to_free) {
1287 if (subtitle_to_free->rects != NULL) {
1288 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1289 av_free(subtitle_to_free->rects[i].bitmap);
1290 av_free(subtitle_to_free->rects[i].rgba_palette);
1292 av_freep(&subtitle_to_free->rects);
1294 subtitle_to_free->num_rects = 0;
1295 subtitle_to_free = NULL;
1302 for(i=0;i<nb_ostreams;i++) {
1304 if (ost->source_index == ist_index) {
1305 AVCodecContext *enc= ost->st->codec;
1306 os = output_files[ost->file_index];
1308 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1310 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1313 if (ost->encoding_needed) {
1317 av_init_packet(&pkt);
1318 pkt.stream_index= ost->index;
1320 switch(ost->st->codec->codec_type) {
1321 case CODEC_TYPE_AUDIO:
1322 fifo_bytes = fifo_size(&ost->fifo, NULL);
1324 /* encode any samples remaining in fifo */
1325 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1326 int fs_tmp = enc->frame_size;
1327 enc->frame_size = fifo_bytes / (2 * enc->channels);
1328 if(fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes,
1329 &ost->fifo.rptr) == 0) {
1330 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1332 enc->frame_size = fs_tmp;
1335 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1338 pkt.flags |= PKT_FLAG_KEY;
1340 case CODEC_TYPE_VIDEO:
1341 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1343 if(enc->coded_frame && enc->coded_frame->key_frame)
1344 pkt.flags |= PKT_FLAG_KEY;
1345 if (ost->logfile && enc->stats_out) {
1346 fprintf(ost->logfile, "%s", enc->stats_out);
1355 pkt.data= bit_buffer;
1357 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1358 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1359 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1373 * The following code is the main loop of the file converter
1375 static int av_encode(AVFormatContext **output_files,
1376 int nb_output_files,
1377 AVFormatContext **input_files,
1379 AVStreamMap *stream_maps, int nb_stream_maps)
1381 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1382 AVFormatContext *is, *os;
1383 AVCodecContext *codec, *icodec;
1384 AVOutputStream *ost, **ost_table = NULL;
1385 AVInputStream *ist, **ist_table = NULL;
1386 AVInputFile *file_table;
1387 AVFormatContext *stream_no_data;
1390 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1394 /* input stream init */
1396 for(i=0;i<nb_input_files;i++) {
1397 is = input_files[i];
1398 file_table[i].ist_index = j;
1399 file_table[i].nb_streams = is->nb_streams;
1400 j += is->nb_streams;
1404 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1408 for(i=0;i<nb_istreams;i++) {
1409 ist = av_mallocz(sizeof(AVInputStream));
1415 for(i=0;i<nb_input_files;i++) {
1416 is = input_files[i];
1417 for(k=0;k<is->nb_streams;k++) {
1418 ist = ist_table[j++];
1419 ist->st = is->streams[k];
1420 ist->file_index = i;
1422 ist->discard = 1; /* the stream is discarded by default
1425 if (ist->st->codec->rate_emu) {
1426 ist->start = av_gettime();
1432 /* output stream init */
1434 for(i=0;i<nb_output_files;i++) {
1435 os = output_files[i];
1436 nb_ostreams += os->nb_streams;
1438 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1439 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1443 /* Sanity check the mapping args -- do the input files & streams exist? */
1444 for(i=0;i<nb_stream_maps;i++) {
1445 int fi = stream_maps[i].file_index;
1446 int si = stream_maps[i].stream_index;
1448 if (fi < 0 || fi > nb_input_files - 1 ||
1449 si < 0 || si > file_table[fi].nb_streams - 1) {
1450 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1453 fi = stream_maps[i].sync_file_index;
1454 si = stream_maps[i].sync_stream_index;
1455 if (fi < 0 || fi > nb_input_files - 1 ||
1456 si < 0 || si > file_table[fi].nb_streams - 1) {
1457 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1462 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1465 for(i=0;i<nb_ostreams;i++) {
1466 ost = av_mallocz(sizeof(AVOutputStream));
1473 for(k=0;k<nb_output_files;k++) {
1474 os = output_files[k];
1475 for(i=0;i<os->nb_streams;i++) {
1477 ost = ost_table[n++];
1478 ost->file_index = k;
1480 ost->st = os->streams[i];
1481 if (nb_stream_maps > 0) {
1482 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1483 stream_maps[n-1].stream_index;
1485 /* Sanity check that the stream types match */
1486 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1487 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1488 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1489 ost->file_index, ost->index);
1494 /* get corresponding input stream index : we select the first one with the right type */
1496 for(j=0;j<nb_istreams;j++) {
1499 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1500 ost->source_index = j;
1507 /* try again and reuse existing stream */
1508 for(j=0;j<nb_istreams;j++) {
1510 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1511 ost->source_index = j;
1516 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1517 ost->file_index, ost->index);
1522 ist = ist_table[ost->source_index];
1524 ost->sync_ist = (nb_stream_maps > 0) ?
1525 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1526 stream_maps[n-1].sync_stream_index] : ist;
1530 /* for each output stream, we compute the right encoding parameters */
1531 for(i=0;i<nb_ostreams;i++) {
1533 ist = ist_table[ost->source_index];
1535 codec = ost->st->codec;
1536 icodec = ist->st->codec;
1538 if (ost->st->stream_copy) {
1539 /* if stream_copy is selected, no need to decode or encode */
1540 codec->codec_id = icodec->codec_id;
1541 codec->codec_type = icodec->codec_type;
1542 if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1543 codec->bit_rate = icodec->bit_rate;
1544 codec->extradata= icodec->extradata;
1545 codec->extradata_size= icodec->extradata_size;
1546 codec->time_base = icodec->time_base;
1547 switch(codec->codec_type) {
1548 case CODEC_TYPE_AUDIO:
1549 codec->sample_rate = icodec->sample_rate;
1550 codec->channels = icodec->channels;
1551 codec->frame_size = icodec->frame_size;
1552 codec->block_align= icodec->block_align;
1554 case CODEC_TYPE_VIDEO:
1555 codec->pix_fmt = icodec->pix_fmt;
1556 codec->width = icodec->width;
1557 codec->height = icodec->height;
1558 codec->has_b_frames = icodec->has_b_frames;
1560 case CODEC_TYPE_SUBTITLE:
1566 switch(codec->codec_type) {
1567 case CODEC_TYPE_AUDIO:
1568 if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1571 if (codec->channels == icodec->channels &&
1572 codec->sample_rate == icodec->sample_rate) {
1573 ost->audio_resample = 0;
1575 if (codec->channels != icodec->channels &&
1576 (icodec->codec_id == CODEC_ID_AC3 ||
1577 icodec->codec_id == CODEC_ID_DTS)) {
1578 /* Special case for 5:1 AC3 and DTS input */
1579 /* and mono or stereo output */
1580 /* Request specific number of channels */
1581 icodec->channels = codec->channels;
1582 if (codec->sample_rate == icodec->sample_rate)
1583 ost->audio_resample = 0;
1585 ost->audio_resample = 1;
1588 ost->audio_resample = 1;
1591 if(audio_sync_method>1)
1592 ost->audio_resample = 1;
1594 if(ost->audio_resample){
1595 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1596 codec->sample_rate, icodec->sample_rate);
1598 printf("Can't resample. Aborting.\n");
1602 ist->decoding_needed = 1;
1603 ost->encoding_needed = 1;
1605 case CODEC_TYPE_VIDEO:
1606 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1607 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1608 ost->video_resample = ((codec->width != icodec->width -
1609 (frame_leftBand + frame_rightBand) +
1610 (frame_padleft + frame_padright)) ||
1611 (codec->height != icodec->height -
1612 (frame_topBand + frame_bottomBand) +
1613 (frame_padtop + frame_padbottom)) ||
1614 (codec->pix_fmt != icodec->pix_fmt));
1615 if (ost->video_crop) {
1616 ost->topBand = frame_topBand;
1617 ost->leftBand = frame_leftBand;
1619 if (ost->video_pad) {
1620 ost->padtop = frame_padtop;
1621 ost->padleft = frame_padleft;
1622 ost->padbottom = frame_padbottom;
1623 ost->padright = frame_padright;
1624 if (!ost->video_resample) {
1625 avcodec_get_frame_defaults(&ost->pict_tmp);
1626 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1627 codec->width, codec->height ) )
1631 if (ost->video_resample) {
1632 avcodec_get_frame_defaults(&ost->pict_tmp);
1633 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1634 codec->width, codec->height ) )
1637 ost->img_resample_ctx = sws_getContext(
1638 icodec->width - (frame_leftBand + frame_rightBand),
1639 icodec->height - (frame_topBand + frame_bottomBand),
1641 codec->width - (frame_padleft + frame_padright),
1642 codec->height - (frame_padtop + frame_padbottom),
1644 sws_flags, NULL, NULL, NULL);
1645 if (ost->img_resample_ctx == NULL) {
1646 fprintf(stderr, "Cannot get resampling context\n");
1649 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1651 ost->encoding_needed = 1;
1652 ist->decoding_needed = 1;
1654 case CODEC_TYPE_SUBTITLE:
1655 ost->encoding_needed = 1;
1656 ist->decoding_needed = 1;
1663 if (ost->encoding_needed &&
1664 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1665 char logfilename[1024];
1670 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1672 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1673 if (codec->flags & CODEC_FLAG_PASS1) {
1674 f = fopen(logfilename, "w");
1676 perror(logfilename);
1681 /* read the log file */
1682 f = fopen(logfilename, "r");
1684 perror(logfilename);
1687 fseek(f, 0, SEEK_END);
1689 fseek(f, 0, SEEK_SET);
1690 logbuffer = av_malloc(size + 1);
1692 fprintf(stderr, "Could not allocate log buffer\n");
1695 size = fread(logbuffer, 1, size, f);
1697 logbuffer[size] = '\0';
1698 codec->stats_in = logbuffer;
1702 if(codec->codec_type == CODEC_TYPE_VIDEO){
1703 int size= codec->width * codec->height;
1704 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1709 bit_buffer = av_malloc(bit_buffer_size);
1713 /* dump the file output parameters - cannot be done before in case
1715 for(i=0;i<nb_output_files;i++) {
1716 dump_format(output_files[i], i, output_files[i]->filename, 1);
1719 /* dump the stream mapping */
1721 fprintf(stderr, "Stream mapping:\n");
1722 for(i=0;i<nb_ostreams;i++) {
1724 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1725 ist_table[ost->source_index]->file_index,
1726 ist_table[ost->source_index]->index,
1729 if (ost->sync_ist != ist_table[ost->source_index])
1730 fprintf(stderr, " [sync #%d.%d]",
1731 ost->sync_ist->file_index,
1732 ost->sync_ist->index);
1733 fprintf(stderr, "\n");
1737 /* open each encoder */
1738 for(i=0;i<nb_ostreams;i++) {
1740 if (ost->encoding_needed) {
1742 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1744 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1745 ost->file_index, ost->index);
1748 if (avcodec_open(ost->st->codec, codec) < 0) {
1749 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1750 ost->file_index, ost->index);
1753 extra_size += ost->st->codec->extradata_size;
1757 /* open each decoder */
1758 for(i=0;i<nb_istreams;i++) {
1760 if (ist->decoding_needed) {
1762 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1764 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1765 ist->st->codec->codec_id, ist->file_index, ist->index);
1768 if (avcodec_open(ist->st->codec, codec) < 0) {
1769 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1770 ist->file_index, ist->index);
1773 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1774 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1779 for(i=0;i<nb_istreams;i++) {
1781 is = input_files[ist->file_index];
1783 ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1784 if(ist->st->start_time == AV_NOPTS_VALUE)
1786 if(input_files_ts_offset[ist->file_index])
1787 ist->next_pts= AV_NOPTS_VALUE;
1791 /* compute buffer size max (should use a complete heuristic) */
1792 for(i=0;i<nb_input_files;i++) {
1793 file_table[i].buffer_size_max = 2048;
1796 /* set meta data information from input file if required */
1797 for (i=0;i<nb_meta_data_maps;i++) {
1798 AVFormatContext *out_file;
1799 AVFormatContext *in_file;
1801 int out_file_index = meta_data_maps[i].out_file;
1802 int in_file_index = meta_data_maps[i].in_file;
1803 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1804 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1808 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1809 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1814 out_file = output_files[out_file_index];
1815 in_file = input_files[in_file_index];
1817 strcpy(out_file->title, in_file->title);
1818 strcpy(out_file->author, in_file->author);
1819 strcpy(out_file->copyright, in_file->copyright);
1820 strcpy(out_file->comment, in_file->comment);
1821 strcpy(out_file->album, in_file->album);
1822 out_file->year = in_file->year;
1823 out_file->track = in_file->track;
1824 strcpy(out_file->genre, in_file->genre);
1827 /* open files and write file headers */
1828 for(i=0;i<nb_output_files;i++) {
1829 os = output_files[i];
1830 if (av_write_header(os) < 0) {
1831 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1838 if ( !using_stdin && verbose >= 0) {
1839 fprintf(stderr, "Press [q] to stop encoding\n");
1840 url_set_interrupt_cb(decode_interrupt_cb);
1848 for(; received_sigterm == 0;) {
1849 int file_index, ist_index;
1857 /* if 'q' pressed, exits */
1861 /* read_key() returns 0 on EOF */
1867 /* select the stream that we must read now by looking at the
1868 smallest output pts */
1870 for(i=0;i<nb_ostreams;i++) {
1873 os = output_files[ost->file_index];
1874 ist = ist_table[ost->source_index];
1875 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1876 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1878 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1879 ipts = (double)ist->pts;
1880 if (!file_table[ist->file_index].eof_reached){
1881 if(ipts < ipts_min) {
1883 if(input_sync ) file_index = ist->file_index;
1885 if(opts < opts_min) {
1887 if(!input_sync) file_index = ist->file_index;
1890 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1895 /* if none, if is finished */
1896 if (file_index < 0) {
1900 /* finish if recording time exhausted */
1901 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1904 /* finish if limit size exhausted */
1905 if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1908 /* read a frame from it and output it in the fifo */
1909 is = input_files[file_index];
1910 if (av_read_frame(is, &pkt) < 0) {
1911 file_table[file_index].eof_reached = 1;
1912 if (opt_shortest) break; else continue; //
1916 stream_no_data = is;
1921 av_pkt_dump(stdout, &pkt, do_hex_dump);
1923 /* the following test is needed in case new streams appear
1924 dynamically in stream : we ignore them */
1925 if (pkt.stream_index >= file_table[file_index].nb_streams)
1926 goto discard_packet;
1927 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1928 ist = ist_table[ist_index];
1930 goto discard_packet;
1932 // 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);
1933 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1934 int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1935 if(ABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1936 input_files_ts_offset[ist->file_index]-= delta;
1938 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1939 for(i=0; i<file_table[file_index].nb_streams; i++){
1940 int index= file_table[file_index].ist_index + i;
1941 ist_table[index]->next_pts += delta;
1942 ist_table[index]->is_start=1;
1947 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1948 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1951 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1952 ist->file_index, ist->index);
1954 av_free_packet(&pkt);
1959 av_free_packet(&pkt);
1961 /* dump report by using the output first video and audio streams */
1962 print_report(output_files, ost_table, nb_ostreams, 0);
1965 /* at the end of stream, we must flush the decoder buffers */
1966 for(i=0;i<nb_istreams;i++) {
1968 if (ist->decoding_needed) {
1969 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1975 /* write the trailer if needed and close file */
1976 for(i=0;i<nb_output_files;i++) {
1977 os = output_files[i];
1978 av_write_trailer(os);
1981 /* dump report by using the first video and audio streams */
1982 print_report(output_files, ost_table, nb_ostreams, 1);
1984 /* close each encoder */
1985 for(i=0;i<nb_ostreams;i++) {
1987 if (ost->encoding_needed) {
1988 av_freep(&ost->st->codec->stats_in);
1989 avcodec_close(ost->st->codec);
1993 /* close each decoder */
1994 for(i=0;i<nb_istreams;i++) {
1996 if (ist->decoding_needed) {
1997 avcodec_close(ist->st->codec);
2005 av_freep(&bit_buffer);
2006 av_free(file_table);
2009 for(i=0;i<nb_istreams;i++) {
2016 for(i=0;i<nb_ostreams;i++) {
2020 fclose(ost->logfile);
2021 ost->logfile = NULL;
2023 fifo_free(&ost->fifo); /* works even if fifo is not
2024 initialized but set to zero */
2025 av_free(ost->pict_tmp.data[0]);
2026 if (ost->video_resample)
2027 sws_freeContext(ost->img_resample_ctx);
2028 if (ost->audio_resample)
2029 audio_resample_close(ost->resample);
2042 int file_read(const char *filename)
2045 unsigned char buffer[1024];
2048 if (url_open(&h, filename, O_RDONLY) < 0) {
2049 printf("could not open '%s'\n", filename);
2053 len = url_read(h, buffer, sizeof(buffer));
2056 for(i=0;i<len;i++) putchar(buffer[i]);
2063 static void opt_image_format(const char *arg)
2067 for(f = first_image_format; f != NULL; f = f->next) {
2068 if (!strcmp(arg, f->name))
2072 fprintf(stderr, "Unknown image format: '%s'\n", arg);
2078 static void opt_format(const char *arg)
2080 /* compatibility stuff for pgmyuv */
2081 if (!strcmp(arg, "pgmyuv")) {
2082 pgmyuv_compatibility_hack=1;
2083 // opt_image_format(arg);
2087 file_iformat = av_find_input_format(arg);
2088 file_oformat = guess_format(arg, NULL, NULL);
2089 if (!file_iformat && !file_oformat) {
2090 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2095 static void opt_video_rc_eq(char *arg)
2100 static void opt_video_rc_override_string(char *arg)
2102 video_rc_override_string = arg;
2105 static void opt_me_threshold(const char *arg)
2107 me_threshold = atoi(arg);
2110 static void opt_mb_threshold(const char *arg)
2112 mb_threshold = atoi(arg);
2115 static void opt_verbose(const char *arg)
2117 verbose = atoi(arg);
2118 av_log_set_level(atoi(arg));
2121 static void opt_frame_rate(const char *arg)
2123 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2124 fprintf(stderr, "Incorrect frame rate\n");
2129 static void opt_frame_crop_top(const char *arg)
2131 frame_topBand = atoi(arg);
2132 if (frame_topBand < 0) {
2133 fprintf(stderr, "Incorrect top crop size\n");
2136 if ((frame_topBand % 2) != 0) {
2137 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2140 if ((frame_topBand) >= frame_height){
2141 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2144 frame_height -= frame_topBand;
2147 static void opt_frame_crop_bottom(const char *arg)
2149 frame_bottomBand = atoi(arg);
2150 if (frame_bottomBand < 0) {
2151 fprintf(stderr, "Incorrect bottom crop size\n");
2154 if ((frame_bottomBand % 2) != 0) {
2155 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2158 if ((frame_bottomBand) >= frame_height){
2159 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2162 frame_height -= frame_bottomBand;
2165 static void opt_frame_crop_left(const char *arg)
2167 frame_leftBand = atoi(arg);
2168 if (frame_leftBand < 0) {
2169 fprintf(stderr, "Incorrect left crop size\n");
2172 if ((frame_leftBand % 2) != 0) {
2173 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2176 if ((frame_leftBand) >= frame_width){
2177 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2180 frame_width -= frame_leftBand;
2183 static void opt_frame_crop_right(const char *arg)
2185 frame_rightBand = atoi(arg);
2186 if (frame_rightBand < 0) {
2187 fprintf(stderr, "Incorrect right crop size\n");
2190 if ((frame_rightBand % 2) != 0) {
2191 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2194 if ((frame_rightBand) >= frame_width){
2195 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2198 frame_width -= frame_rightBand;
2201 static void opt_frame_size(const char *arg)
2203 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2204 fprintf(stderr, "Incorrect frame size\n");
2207 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2208 fprintf(stderr, "Frame size must be a multiple of 2\n");
2214 #define SCALEBITS 10
2215 #define ONE_HALF (1 << (SCALEBITS - 1))
2216 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2218 #define RGB_TO_Y(r, g, b) \
2219 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2220 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2222 #define RGB_TO_U(r1, g1, b1, shift)\
2223 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2224 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2226 #define RGB_TO_V(r1, g1, b1, shift)\
2227 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2228 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2230 static void opt_pad_color(const char *arg) {
2231 /* Input is expected to be six hex digits similar to
2232 how colors are expressed in html tags (but without the #) */
2233 int rgb = strtol(arg, NULL, 16);
2237 g = ((rgb >> 8) & 255);
2240 padcolor[0] = RGB_TO_Y(r,g,b);
2241 padcolor[1] = RGB_TO_U(r,g,b,0);
2242 padcolor[2] = RGB_TO_V(r,g,b,0);
2245 static void opt_frame_pad_top(const char *arg)
2247 frame_padtop = atoi(arg);
2248 if (frame_padtop < 0) {
2249 fprintf(stderr, "Incorrect top pad size\n");
2252 if ((frame_padtop % 2) != 0) {
2253 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2258 static void opt_frame_pad_bottom(const char *arg)
2260 frame_padbottom = atoi(arg);
2261 if (frame_padbottom < 0) {
2262 fprintf(stderr, "Incorrect bottom pad size\n");
2265 if ((frame_padbottom % 2) != 0) {
2266 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2272 static void opt_frame_pad_left(const char *arg)
2274 frame_padleft = atoi(arg);
2275 if (frame_padleft < 0) {
2276 fprintf(stderr, "Incorrect left pad size\n");
2279 if ((frame_padleft % 2) != 0) {
2280 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2286 static void opt_frame_pad_right(const char *arg)
2288 frame_padright = atoi(arg);
2289 if (frame_padright < 0) {
2290 fprintf(stderr, "Incorrect right pad size\n");
2293 if ((frame_padright % 2) != 0) {
2294 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2300 static void opt_frame_pix_fmt(const char *arg)
2302 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2305 static void opt_frame_aspect_ratio(const char *arg)
2311 p = strchr(arg, ':');
2313 x = strtol(arg, (char **)&arg, 10);
2315 y = strtol(arg+1, (char **)&arg, 10);
2317 ar = (double)x / (double)y;
2319 ar = strtod(arg, (char **)&arg);
2322 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2325 frame_aspect_ratio = ar;
2328 static void opt_qscale(const char *arg)
2330 video_qscale = atof(arg);
2331 if (video_qscale <= 0 ||
2332 video_qscale > 255) {
2333 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2338 static void opt_lmax(const char *arg)
2340 video_lmax = atof(arg)*FF_QP2LAMBDA;
2343 static void opt_lmin(const char *arg)
2345 video_lmin = atof(arg)*FF_QP2LAMBDA;
2348 static void opt_mb_lmin(const char *arg)
2350 video_mb_lmin = atof(arg)*FF_QP2LAMBDA;
2351 if (video_mb_lmin < 1 ||
2352 video_mb_lmin > FF_LAMBDA_MAX) {
2353 fprintf(stderr, "mblmin must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2358 static void opt_mb_lmax(const char *arg)
2360 video_mb_lmax = atof(arg)*FF_QP2LAMBDA;
2361 if (video_mb_lmax < 1 ||
2362 video_mb_lmax > FF_LAMBDA_MAX) {
2363 fprintf(stderr, "mblmax must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2368 static void opt_qdiff(const char *arg)
2370 video_qdiff = atoi(arg);
2371 if (video_qdiff < 0 ||
2373 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2378 static void opt_packet_size(const char *arg)
2380 packet_size= atoi(arg);
2383 static void opt_error_rate(const char *arg)
2385 error_rate= atoi(arg);
2388 static void opt_strict(const char *arg)
2393 static void opt_top_field_first(const char *arg)
2395 top_field_first= atoi(arg);
2398 static void opt_sc_threshold(const char *arg)
2400 sc_threshold= atoi(arg);
2403 static void opt_thread_count(const char *arg)
2405 thread_count= atoi(arg);
2406 #if !defined(HAVE_THREADS)
2408 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2412 static void opt_audio_bitrate(const char *arg)
2414 audio_bit_rate = atoi(arg) * 1000;
2417 static void opt_audio_rate(const char *arg)
2419 audio_sample_rate = atoi(arg);
2422 static void opt_audio_channels(const char *arg)
2424 audio_channels = atoi(arg);
2427 static void opt_video_device(const char *arg)
2429 video_device = av_strdup(arg);
2432 static void opt_grab_device(const char *arg)
2434 grab_device = av_strdup(arg);
2437 static void opt_video_channel(const char *arg)
2439 video_channel = strtol(arg, NULL, 0);
2442 static void opt_video_standard(const char *arg)
2444 video_standard = av_strdup(arg);
2447 static void opt_audio_device(const char *arg)
2449 audio_device = av_strdup(arg);
2452 static void opt_codec(int *pstream_copy, int *pcodec_id,
2453 int codec_type, const char *arg)
2457 if (!strcmp(arg, "copy")) {
2462 if (!strcmp(p->name, arg) && p->type == codec_type)
2467 fprintf(stderr, "Unknown codec '%s'\n", arg);
2475 static void opt_audio_codec(const char *arg)
2477 opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2480 static void opt_audio_tag(const char *arg)
2483 audio_codec_tag= strtol(arg, &tail, 0);
2486 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2489 static void opt_video_tag(const char *arg)
2492 video_codec_tag= strtol(arg, &tail, 0);
2495 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2498 static void add_frame_hooker(const char *arg)
2503 char *args = av_strdup(arg);
2507 argv[0] = strtok(args, " ");
2508 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2511 i = frame_hook_add(argc, argv);
2514 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2519 const char *motion_str[] = {
2532 static void opt_motion_estimation(const char *arg)
2538 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2541 if (!strcmp(*p, arg))
2545 me_method = (p - motion_str) + 1;
2548 static void opt_video_codec(const char *arg)
2550 opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2553 static void opt_subtitle_codec(const char *arg)
2555 opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2558 static void opt_map(const char *arg)
2564 m = &stream_maps[nb_stream_maps++];
2566 m->file_index = strtol(arg, (char **)&p, 0);
2570 m->stream_index = strtol(p, (char **)&p, 0);
2573 m->sync_file_index = strtol(p, (char **)&p, 0);
2576 m->sync_stream_index = strtol(p, (char **)&p, 0);
2578 m->sync_file_index = m->file_index;
2579 m->sync_stream_index = m->stream_index;
2583 static void opt_map_meta_data(const char *arg)
2589 m = &meta_data_maps[nb_meta_data_maps++];
2591 m->out_file = strtol(arg, (char **)&p, 0);
2595 m->in_file = strtol(p, (char **)&p, 0);
2598 static void opt_recording_time(const char *arg)
2600 recording_time = parse_date(arg, 1);
2603 static void opt_start_time(const char *arg)
2605 start_time = parse_date(arg, 1);
2608 static void opt_rec_timestamp(const char *arg)
2610 rec_timestamp = parse_date(arg, 0) / 1000000;
2613 static void opt_input_ts_offset(const char *arg)
2615 input_ts_offset = parse_date(arg, 1);
2618 static void opt_input_file(const char *filename)
2620 AVFormatContext *ic;
2621 AVFormatParameters params, *ap = ¶ms;
2622 int err, i, ret, rfps, rfps_base;
2625 if (!strcmp(filename, "-"))
2628 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2629 !strcmp( filename, "/dev/stdin" );
2631 /* get default parameters from command line */
2632 ic = av_alloc_format_context();
2634 memset(ap, 0, sizeof(*ap));
2635 ap->prealloced_context = 1;
2636 ap->sample_rate = audio_sample_rate;
2637 ap->channels = audio_channels;
2638 ap->time_base.den = frame_rate;
2639 ap->time_base.num = frame_rate_base;
2640 ap->width = frame_width + frame_padleft + frame_padright;
2641 ap->height = frame_height + frame_padtop + frame_padbottom;
2642 ap->image_format = image_format;
2643 ap->pix_fmt = frame_pix_fmt;
2644 ap->device = grab_device;
2645 ap->channel = video_channel;
2646 ap->standard = video_standard;
2647 ap->video_codec_id = video_codec_id;
2648 ap->audio_codec_id = audio_codec_id;
2649 if(pgmyuv_compatibility_hack)
2650 ap->video_codec_id= CODEC_ID_PGMYUV;
2652 for(i=0; i<opt_name_count; i++){
2654 double d= av_get_double(avformat_opts, opt_names[i], &opt);
2655 if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2656 av_set_double(ic, opt_names[i], d);
2658 /* open the input file with generic libav function */
2659 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2661 print_error(filename, err);
2665 ic->loop_input = loop_input;
2667 /* If not enough info to get the stream parameters, we decode the
2668 first frames to get it. (used in mpeg case for example) */
2669 ret = av_find_stream_info(ic);
2670 if (ret < 0 && verbose >= 0) {
2671 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2675 timestamp = start_time;
2676 /* add the stream start time */
2677 if (ic->start_time != AV_NOPTS_VALUE)
2678 timestamp += ic->start_time;
2680 /* if seeking requested, we execute it */
2681 if (start_time != 0) {
2682 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2684 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2685 filename, (double)timestamp / AV_TIME_BASE);
2687 /* reset seek info */
2691 /* update the current parameters so that they match the one of the input stream */
2692 for(i=0;i<ic->nb_streams;i++) {
2694 AVCodecContext *enc = ic->streams[i]->codec;
2695 #if defined(HAVE_THREADS)
2697 avcodec_thread_init(enc, thread_count);
2699 enc->thread_count= thread_count;
2700 switch(enc->codec_type) {
2701 case CODEC_TYPE_AUDIO:
2702 for(j=0; j<opt_name_count; j++){
2704 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2705 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2706 av_set_double(enc, opt_names[j], d);
2708 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2709 audio_channels = enc->channels;
2710 audio_sample_rate = enc->sample_rate;
2712 ic->streams[i]->discard= AVDISCARD_ALL;
2714 case CODEC_TYPE_VIDEO:
2715 for(j=0; j<opt_name_count; j++){
2717 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2718 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2719 av_set_double(enc, opt_names[j], d);
2721 frame_height = enc->height;
2722 frame_width = enc->width;
2723 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2724 frame_pix_fmt = enc->pix_fmt;
2725 rfps = ic->streams[i]->r_frame_rate.num;
2726 rfps_base = ic->streams[i]->r_frame_rate.den;
2727 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2729 enc->debug |= FF_DEBUG_MV;
2731 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2734 fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2735 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2737 (float)rfps / rfps_base, rfps, rfps_base);
2739 /* update the current frame rate to match the stream frame rate */
2741 frame_rate_base = rfps_base;
2743 enc->rate_emu = rate_emu;
2745 ic->streams[i]->discard= AVDISCARD_ALL;
2746 else if(video_discard)
2747 ic->streams[i]->discard= video_discard;
2749 case CODEC_TYPE_DATA:
2751 case CODEC_TYPE_SUBTITLE:
2753 case CODEC_TYPE_UNKNOWN:
2760 input_files[nb_input_files] = ic;
2761 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2762 /* dump the file content */
2764 dump_format(ic, nb_input_files, filename, 0);
2767 file_iformat = NULL;
2768 file_oformat = NULL;
2769 image_format = NULL;
2777 static void opt_grab(const char *arg)
2779 file_iformat = av_find_input_format(arg);
2783 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2785 int has_video, has_audio, i, j;
2786 AVFormatContext *ic;
2790 for(j=0;j<nb_input_files;j++) {
2791 ic = input_files[j];
2792 for(i=0;i<ic->nb_streams;i++) {
2793 AVCodecContext *enc = ic->streams[i]->codec;
2794 switch(enc->codec_type) {
2795 case CODEC_TYPE_AUDIO:
2798 case CODEC_TYPE_VIDEO:
2801 case CODEC_TYPE_DATA:
2802 case CODEC_TYPE_UNKNOWN:
2803 case CODEC_TYPE_SUBTITLE:
2810 *has_video_ptr = has_video;
2811 *has_audio_ptr = has_audio;
2814 static void new_video_stream(AVFormatContext *oc)
2817 AVCodecContext *video_enc;
2820 st = av_new_stream(oc, oc->nb_streams);
2822 fprintf(stderr, "Could not alloc stream\n");
2825 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2826 video_bitstream_filters= NULL;
2828 #if defined(HAVE_THREADS)
2830 avcodec_thread_init(st->codec, thread_count);
2833 video_enc = st->codec;
2836 video_enc->codec_tag= video_codec_tag;
2838 if( (video_global_header&1)
2839 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2840 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2841 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2843 if(video_global_header&2){
2844 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2845 avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2848 if (video_stream_copy) {
2849 st->stream_copy = 1;
2850 video_enc->codec_type = CODEC_TYPE_VIDEO;
2856 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2857 if (video_codec_id != CODEC_ID_NONE)
2858 codec_id = video_codec_id;
2860 video_enc->codec_id = codec_id;
2861 codec = avcodec_find_encoder(codec_id);
2863 for(i=0; i<opt_name_count; i++){
2865 double d= av_get_double(avctx_opts, opt_names[i], &opt);
2866 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2867 av_set_double(video_enc, opt_names[i], d);
2870 video_enc->time_base.den = frame_rate;
2871 video_enc->time_base.num = frame_rate_base;
2872 if(codec && codec->supported_framerates){
2873 const AVRational *p= codec->supported_framerates;
2874 AVRational req= (AVRational){frame_rate, frame_rate_base};
2875 const AVRational *best=NULL;
2876 AVRational best_error= (AVRational){INT_MAX, 1};
2877 for(; p->den!=0; p++){
2878 AVRational error= av_sub_q(req, *p);
2879 if(error.num <0) error.num *= -1;
2880 if(av_cmp_q(error, best_error) < 0){
2885 video_enc->time_base.den= best->num;
2886 video_enc->time_base.num= best->den;
2889 video_enc->width = frame_width + frame_padright + frame_padleft;
2890 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2891 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2892 video_enc->pix_fmt = frame_pix_fmt;
2894 if(codec && codec->pix_fmts){
2895 const enum PixelFormat *p= codec->pix_fmts;
2897 if(*p == video_enc->pix_fmt)
2901 video_enc->pix_fmt = codec->pix_fmts[0];
2905 video_enc->gop_size = 0;
2906 if (video_qscale || same_quality) {
2907 video_enc->flags |= CODEC_FLAG_QSCALE;
2908 video_enc->global_quality=
2909 st->quality = FF_QP2LAMBDA * video_qscale;
2913 video_enc->intra_matrix = intra_matrix;
2915 video_enc->inter_matrix = inter_matrix;
2917 video_enc->lmin = video_lmin;
2918 video_enc->lmax = video_lmax;
2919 video_enc->mb_lmin = video_mb_lmin;
2920 video_enc->mb_lmax = video_mb_lmax;
2921 video_enc->max_qdiff = video_qdiff;
2922 video_enc->rc_eq = video_rc_eq;
2923 video_enc->thread_count = thread_count;
2924 p= video_rc_override_string;
2927 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2929 fprintf(stderr, "error parsing rc_override\n");
2932 video_enc->rc_override=
2933 av_realloc(video_enc->rc_override,
2934 sizeof(RcOverride)*(i+1));
2935 video_enc->rc_override[i].start_frame= start;
2936 video_enc->rc_override[i].end_frame = end;
2938 video_enc->rc_override[i].qscale= q;
2939 video_enc->rc_override[i].quality_factor= 1.0;
2942 video_enc->rc_override[i].qscale= 0;
2943 video_enc->rc_override[i].quality_factor= -q/100.0;
2948 video_enc->rc_override_count=i;
2949 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2950 video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
2951 video_enc->me_threshold= me_threshold;
2952 video_enc->mb_threshold= mb_threshold;
2953 video_enc->intra_dc_precision= intra_dc_precision - 8;
2954 video_enc->strict_std_compliance = strict;
2955 video_enc->error_rate = error_rate;
2956 video_enc->scenechange_threshold= sc_threshold;
2957 video_enc->me_penalty_compensation= me_penalty_compensation;
2958 video_enc->frame_skip_threshold= frame_skip_threshold;
2959 video_enc->frame_skip_factor= frame_skip_factor;
2960 video_enc->frame_skip_exp= frame_skip_exp;
2963 video_enc->rtp_mode= 1;
2964 video_enc->rtp_payload_size= packet_size;
2968 video_enc->flags|= CODEC_FLAG_PSNR;
2970 video_enc->me_method = me_method;
2975 video_enc->flags |= CODEC_FLAG_PASS1;
2977 video_enc->flags |= CODEC_FLAG_PASS2;
2982 /* reset some key parameters */
2984 video_codec_id = CODEC_ID_NONE;
2985 video_stream_copy = 0;
2988 static void new_audio_stream(AVFormatContext *oc)
2991 AVCodecContext *audio_enc;
2994 st = av_new_stream(oc, oc->nb_streams);
2996 fprintf(stderr, "Could not alloc stream\n");
3000 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3001 audio_bitstream_filters= NULL;
3003 #if defined(HAVE_THREADS)
3005 avcodec_thread_init(st->codec, thread_count);
3008 audio_enc = st->codec;
3009 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3012 audio_enc->codec_tag= audio_codec_tag;
3014 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3015 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3016 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
3018 if (audio_stream_copy) {
3019 st->stream_copy = 1;
3020 audio_enc->channels = audio_channels;
3022 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3024 for(i=0; i<opt_name_count; i++){
3026 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3027 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3028 av_set_double(audio_enc, opt_names[i], d);
3031 if (audio_codec_id != CODEC_ID_NONE)
3032 codec_id = audio_codec_id;
3033 audio_enc->codec_id = codec_id;
3035 audio_enc->bit_rate = audio_bit_rate;
3036 if (audio_qscale > QSCALE_NONE) {
3037 audio_enc->flags |= CODEC_FLAG_QSCALE;
3038 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3040 audio_enc->strict_std_compliance = strict;
3041 audio_enc->thread_count = thread_count;
3042 /* For audio codecs other than AC3 or DTS we limit */
3043 /* the number of coded channels to stereo */
3044 if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3045 && codec_id != CODEC_ID_DTS) {
3046 audio_enc->channels = 2;
3048 audio_enc->channels = audio_channels;
3050 audio_enc->sample_rate = audio_sample_rate;
3051 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3052 if (audio_language) {
3053 pstrcpy(st->language, sizeof(st->language), audio_language);
3054 av_free(audio_language);
3055 audio_language = NULL;
3058 /* reset some key parameters */
3060 audio_codec_id = CODEC_ID_NONE;
3061 audio_stream_copy = 0;
3064 static void opt_new_subtitle_stream(void)
3066 AVFormatContext *oc;
3068 AVCodecContext *subtitle_enc;
3071 if (nb_output_files <= 0) {
3072 fprintf(stderr, "At least one output file must be specified\n");
3075 oc = output_files[nb_output_files - 1];
3077 st = av_new_stream(oc, oc->nb_streams);
3079 fprintf(stderr, "Could not alloc stream\n");
3083 subtitle_enc = st->codec;
3084 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3085 if (subtitle_stream_copy) {
3086 st->stream_copy = 1;
3088 for(i=0; i<opt_name_count; i++){
3090 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3091 if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3092 av_set_double(subtitle_enc, opt_names[i], d);
3094 subtitle_enc->codec_id = subtitle_codec_id;
3097 if (subtitle_language) {
3098 pstrcpy(st->language, sizeof(st->language), subtitle_language);
3099 av_free(subtitle_language);
3100 subtitle_language = NULL;
3103 subtitle_codec_id = CODEC_ID_NONE;
3104 subtitle_stream_copy = 0;
3107 static void opt_new_audio_stream(void)
3109 AVFormatContext *oc;
3110 if (nb_output_files <= 0) {
3111 fprintf(stderr, "At least one output file must be specified\n");
3114 oc = output_files[nb_output_files - 1];
3115 new_audio_stream(oc);
3118 static void opt_new_video_stream(void)
3120 AVFormatContext *oc;
3121 if (nb_output_files <= 0) {
3122 fprintf(stderr, "At least one output file must be specified\n");
3125 oc = output_files[nb_output_files - 1];
3126 new_video_stream(oc);
3129 static void opt_output_file(const char *filename)
3131 AVFormatContext *oc;
3132 int use_video, use_audio, input_has_video, input_has_audio, i;
3133 AVFormatParameters params, *ap = ¶ms;
3135 if (!strcmp(filename, "-"))
3138 oc = av_alloc_format_context();
3140 if (!file_oformat) {
3141 file_oformat = guess_format(NULL, filename, NULL);
3142 if (!file_oformat) {
3143 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3149 oc->oformat = file_oformat;
3150 pstrcpy(oc->filename, sizeof(oc->filename), filename);
3152 if (!strcmp(file_oformat->name, "ffm") &&
3153 strstart(filename, "http:", NULL)) {
3154 /* special case for files sent to ffserver: we get the stream
3155 parameters from ffserver */
3156 if (read_ffserver_streams(oc, filename) < 0) {
3157 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3161 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3162 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3164 /* disable if no corresponding type found and at least one
3166 if (nb_input_files > 0) {
3167 check_audio_video_inputs(&input_has_video, &input_has_audio);
3168 if (!input_has_video)
3170 if (!input_has_audio)
3174 /* manual disable */
3175 if (audio_disable) {
3178 if (video_disable) {
3183 new_video_stream(oc);
3187 new_audio_stream(oc);
3190 if (!oc->nb_streams) {
3191 fprintf(stderr, "No audio or video streams available\n");
3195 oc->timestamp = rec_timestamp;
3198 pstrcpy(oc->title, sizeof(oc->title), str_title);
3200 pstrcpy(oc->author, sizeof(oc->author), str_author);
3202 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3204 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3206 pstrcpy(oc->album, sizeof(oc->album), str_album);
3209 output_files[nb_output_files++] = oc;
3211 /* check filename in case of an image number is expected */
3212 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3213 if (!av_filename_number_test(oc->filename)) {
3214 print_error(oc->filename, AVERROR_NUMEXPECTED);
3219 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3220 /* test if it already exists to avoid loosing precious files */
3221 if (!file_overwrite &&
3222 (strchr(filename, ':') == NULL ||
3223 strstart(filename, "file:", NULL))) {
3224 if (url_exist(filename)) {
3227 if ( !using_stdin ) {
3228 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3231 if (toupper(c) != 'Y') {
3232 fprintf(stderr, "Not overwriting - exiting\n");
3237 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3244 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3245 fprintf(stderr, "Could not open '%s'\n", filename);
3250 memset(ap, 0, sizeof(*ap));
3251 ap->image_format = image_format;
3252 if (av_set_parameters(oc, ap) < 0) {
3253 fprintf(stderr, "%s: Invalid encoding parameters\n",
3258 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3259 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3260 oc->loop_output = loop_output;
3262 for(i=0; i<opt_name_count; i++){
3264 double d = av_get_double(avformat_opts, opt_names[i], &opt);
3265 if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3266 av_set_double(oc, opt_names[i], d);
3269 /* reset some options */
3270 file_oformat = NULL;
3271 file_iformat = NULL;
3272 image_format = NULL;
3275 /* prepare dummy protocols for grab */
3276 static void prepare_grab(void)
3278 int has_video, has_audio, i, j;
3279 AVFormatContext *oc;
3280 AVFormatContext *ic;
3281 AVFormatParameters vp1, *vp = &vp1;
3282 AVFormatParameters ap1, *ap = &ap1;
3284 /* see if audio/video inputs are needed */
3287 memset(ap, 0, sizeof(*ap));
3288 memset(vp, 0, sizeof(*vp));
3289 vp->time_base.num= 1;
3290 for(j=0;j<nb_output_files;j++) {
3291 oc = output_files[j];
3292 for(i=0;i<oc->nb_streams;i++) {
3293 AVCodecContext *enc = oc->streams[i]->codec;
3294 switch(enc->codec_type) {
3295 case CODEC_TYPE_AUDIO:
3296 if (enc->sample_rate > ap->sample_rate)
3297 ap->sample_rate = enc->sample_rate;
3298 if (enc->channels > ap->channels)
3299 ap->channels = enc->channels;
3302 case CODEC_TYPE_VIDEO:
3303 if (enc->width > vp->width)
3304 vp->width = enc->width;
3305 if (enc->height > vp->height)
3306 vp->height = enc->height;
3308 if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3309 vp->time_base = enc->time_base;
3310 vp->width += frame_leftBand + frame_rightBand;
3311 vp->width -= (frame_padleft + frame_padright);
3312 vp->height += frame_topBand + frame_bottomBand;
3313 vp->height -= (frame_padtop + frame_padbottom);
3323 if (has_video == 0 && has_audio == 0) {
3324 fprintf(stderr, "Output file must have at least one audio or video stream\n");
3329 AVInputFormat *fmt1;
3330 fmt1 = av_find_input_format(video_grab_format);
3331 vp->device = video_device;
3332 vp->channel = video_channel;
3333 vp->standard = video_standard;
3334 vp->pix_fmt = frame_pix_fmt;
3335 if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3336 fprintf(stderr, "Could not find video grab device\n");
3339 /* If not enough info to get the stream parameters, we decode the
3340 first frames to get it. */
3341 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3342 fprintf(stderr, "Could not find video grab parameters\n");
3345 /* by now video grab has one stream */
3346 ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3347 ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3348 input_files[nb_input_files] = ic;
3351 dump_format(ic, nb_input_files, "", 0);
3355 if (has_audio && audio_grab_format) {
3356 AVInputFormat *fmt1;
3357 fmt1 = av_find_input_format(audio_grab_format);
3358 ap->device = audio_device;
3359 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3360 fprintf(stderr, "Could not find audio grab device\n");
3363 input_files[nb_input_files] = ic;
3366 dump_format(ic, nb_input_files, "", 0);
3372 /* same option as mencoder */
3373 static void opt_pass(const char *pass_str)
3376 pass = atoi(pass_str);
3377 if (pass != 1 && pass != 2) {
3378 fprintf(stderr, "pass number can be only 1 or 2\n");
3384 #if defined(__MINGW32__) || defined(CONFIG_OS2)
3385 static int64_t getutime(void)
3387 return av_gettime();
3390 static int64_t getutime(void)
3392 struct rusage rusage;
3394 getrusage(RUSAGE_SELF, &rusage);
3395 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3399 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3400 extern int ffm_nopts;
3403 static void show_formats(void)
3405 AVInputFormat *ifmt;
3406 AVOutputFormat *ofmt;
3407 AVImageFormat *image_fmt;
3410 const char **pp, *last_name;
3412 printf("File formats:\n");
3417 const char *name=NULL;
3418 const char *long_name=NULL;
3420 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3421 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3422 strcmp(ofmt->name, last_name)>0){
3424 long_name= ofmt->long_name;
3428 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3429 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3430 strcmp(ifmt->name, last_name)>0){
3432 long_name= ifmt->long_name;
3435 if(name && strcmp(ifmt->name, name)==0)
3447 long_name ? long_name:" ");
3451 printf("Image formats (filename extensions, if any, follow):\n");
3452 for(image_fmt = first_image_format; image_fmt != NULL;
3453 image_fmt = image_fmt->next) {
3456 image_fmt->img_read ? "D":" ",
3457 image_fmt->img_write ? "E":" ",
3459 image_fmt->extensions ? image_fmt->extensions:" ");
3463 printf("Codecs:\n");
3469 const char *type_str;
3472 for(p = first_avcodec; p != NULL; p = p->next) {
3473 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3474 strcmp(p->name, last_name)>0){
3476 decode= encode= cap=0;
3478 if(p2 && strcmp(p->name, p2->name)==0){
3479 if(p->decode) decode=1;
3480 if(p->encode) encode=1;
3481 cap |= p->capabilities;
3486 last_name= p2->name;
3489 case CODEC_TYPE_VIDEO:
3492 case CODEC_TYPE_AUDIO:
3495 case CODEC_TYPE_SUBTITLE:
3504 decode ? "D": (/*p2->decoder ? "d":*/" "),
3507 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3508 cap & CODEC_CAP_DR1 ? "D":" ",
3509 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3511 /* if(p2->decoder && decode==0)
3512 printf(" use %s for decoding", p2->decoder->name);*/
3517 printf("Supported file protocols:\n");
3518 for(up = first_protocol; up != NULL; up = up->next)
3519 printf(" %s:", up->name);
3522 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3523 printf("Motion estimation methods:\n");
3527 if ((pp - motion_str + 1) == ME_ZERO)
3528 printf("(fastest)");
3529 else if ((pp - motion_str + 1) == ME_FULL)
3530 printf("(slowest)");
3531 else if ((pp - motion_str + 1) == ME_EPZS)
3532 printf("(default)");
3537 "Note, the names of encoders and decoders dont always match, so there are\n"
3538 "several cases where the above table shows encoder only or decoder only entries\n"
3539 "even though both encoding and decoding are supported for example, the h263\n"
3540 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3545 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3548 const char *p = str;
3555 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3562 static void opt_inter_matrix(const char *arg)
3564 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3565 parse_matrix_coeffs(inter_matrix, arg);
3568 static void opt_intra_matrix(const char *arg)
3570 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3571 parse_matrix_coeffs(intra_matrix, arg);
3574 static void opt_target(const char *arg)
3577 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3579 if(!strncmp(arg, "pal-", 4)) {
3582 } else if(!strncmp(arg, "ntsc-", 5)) {
3585 } else if(!strncmp(arg, "film-", 5)) {
3590 /* Calculate FR via float to avoid int overflow */
3591 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3594 } else if((fr == 29970) || (fr == 23976)) {
3597 /* Try to determine PAL/NTSC by peeking in the input files */
3598 if(nb_input_files) {
3600 for(j = 0; j < nb_input_files; j++) {
3601 for(i = 0; i < input_files[j]->nb_streams; i++) {
3602 AVCodecContext *c = input_files[j]->streams[i]->codec;
3603 if(c->codec_type != CODEC_TYPE_VIDEO)
3605 fr = c->time_base.den * 1000 / c->time_base.num;
3609 } else if((fr == 29970) || (fr == 23976)) {
3619 if(verbose && norm >= 0)
3620 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3624 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3625 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3626 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3630 if(!strcmp(arg, "vcd")) {
3632 opt_video_codec("mpeg1video");
3633 opt_audio_codec("mp2");
3636 opt_frame_size(norm ? "352x240" : "352x288");
3637 opt_frame_rate(frame_rates[norm]);
3638 opt_default("gop", norm ? "18" : "15");
3640 opt_default("b", "1150000");
3641 opt_default("maxrate", "1150000");
3642 opt_default("minrate", "1150000");
3643 opt_default("bufsize", "327680"); // 40*1024*8;
3645 audio_bit_rate = 224000;
3646 audio_sample_rate = 44100;
3648 opt_default("packetsize", "2324");
3649 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3651 /* We have to offset the PTS, so that it is consistent with the SCR.
3652 SCR starts at 36000, but the first two packs contain only padding
3653 and the first pack from the other stream, respectively, may also have
3654 been written before.
3655 So the real data starts at SCR 36000+3*1200. */
3656 mux_preload= (36000+3*1200) / 90000.0; //0.44
3657 } else if(!strcmp(arg, "svcd")) {
3659 opt_video_codec("mpeg2video");
3660 opt_audio_codec("mp2");
3663 opt_frame_size(norm ? "480x480" : "480x576");
3664 opt_frame_rate(frame_rates[norm]);
3665 opt_default("gop", norm ? "18" : "15");
3667 opt_default("b", "2040000");
3668 opt_default("maxrate", "2516000");
3669 opt_default("minrate", "0"); //1145000;
3670 opt_default("bufsize", "1835008"); //224*1024*8;
3671 opt_default("flags", "+SCAN_OFFSET");
3674 audio_bit_rate = 224000;
3675 audio_sample_rate = 44100;
3677 opt_default("packetsize", "2324");
3679 } else if(!strcmp(arg, "dvd")) {
3681 opt_video_codec("mpeg2video");
3682 opt_audio_codec("ac3");
3685 opt_frame_size(norm ? "720x480" : "720x576");
3686 opt_frame_rate(frame_rates[norm]);
3687 opt_default("gop", norm ? "18" : "15");
3689 opt_default("b", "6000000");
3690 opt_default("maxrate", "9000000");
3691 opt_default("minrate", "0"); //1500000;
3692 opt_default("bufsize", "1835008"); //224*1024*8;
3694 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3695 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3697 audio_bit_rate = 448000;
3698 audio_sample_rate = 48000;
3700 } else if(!strncmp(arg, "dv", 2)) {
3704 opt_frame_size(norm ? "720x480" : "720x576");
3705 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3706 (norm ? "yuv411p" : "yuv420p"));
3707 opt_frame_rate(frame_rates[norm]);
3709 audio_sample_rate = 48000;
3713 fprintf(stderr, "Unknown target: %s\n", arg);
3718 static void opt_video_bsf(const char *arg)
3720 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3721 AVBitStreamFilterContext **bsfp;
3724 fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3728 bsfp= &video_bitstream_filters;