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 int me_method = ME_EPZS;
124 static int video_disable = 0;
125 static int video_discard = 0;
126 static int video_codec_id = CODEC_ID_NONE;
127 static int video_codec_tag = 0;
128 static int same_quality = 0;
129 static int do_deinterlace = 0;
130 static int packet_size = 0;
131 static int error_rate = 0;
132 static int strict = 0;
133 static int top_field_first = -1;
134 static int me_threshold = 0;
135 static int mb_threshold = 0;
136 static int intra_dc_precision = 8;
137 static int me_penalty_compensation= 256;
138 static int frame_skip_threshold= 0;
139 static int frame_skip_factor= 0;
140 static int frame_skip_exp= 0;
141 static int loop_input = 0;
142 static int loop_output = AVFMT_NOOUTPUTLOOP;
143 static int qp_hist = 0;
145 static int intra_only = 0;
146 static int audio_sample_rate = 44100;
147 static int audio_bit_rate = 64000;
148 #define QSCALE_NONE -99999
149 static float audio_qscale = QSCALE_NONE;
150 static int audio_disable = 0;
151 static int audio_channels = 1;
152 static int audio_codec_id = CODEC_ID_NONE;
153 static int audio_codec_tag = 0;
154 static char *audio_language = NULL;
156 static int subtitle_codec_id = CODEC_ID_NONE;
157 static char *subtitle_language = NULL;
159 static float mux_preload= 0.5;
160 static float mux_max_delay= 0.7;
162 static int64_t recording_time = 0;
163 static int64_t start_time = 0;
164 static int64_t rec_timestamp = 0;
165 static int64_t input_ts_offset = 0;
166 static int file_overwrite = 0;
167 static char *str_title = NULL;
168 static char *str_author = NULL;
169 static char *str_copyright = NULL;
170 static char *str_comment = NULL;
171 static char *str_album = NULL;
172 static int do_benchmark = 0;
173 static int do_hex_dump = 0;
174 static int do_pkt_dump = 0;
175 static int do_psnr = 0;
176 static int do_vstats = 0;
177 static int do_pass = 0;
178 static char *pass_logfilename = NULL;
179 static int audio_stream_copy = 0;
180 static int video_stream_copy = 0;
181 static int subtitle_stream_copy = 0;
182 static int video_sync_method= 1;
183 static int audio_sync_method= 0;
184 static int copy_ts= 0;
185 static int opt_shortest = 0; //
186 static int video_global_header = 0;
188 static int rate_emu = 0;
191 static const char *video_grab_format = "bktr";
193 #ifdef CONFIG_VIDEO4LINUX2
194 static const char *video_grab_format = "video4linux2";
196 static const char *video_grab_format = "video4linux";
199 static char *video_device = NULL;
200 static char *grab_device = NULL;
201 static int video_channel = 0;
202 static char *video_standard = "ntsc";
204 static const char *audio_grab_format = "audio_device";
205 static char *audio_device = NULL;
206 static int audio_volume = 256;
208 static int using_stdin = 0;
209 static int using_vhook = 0;
210 static int verbose = 1;
211 static int thread_count= 1;
212 static int q_pressed = 0;
213 static int64_t video_size = 0;
214 static int64_t audio_size = 0;
215 static int64_t extra_size = 0;
216 static int nb_frames_dup = 0;
217 static int nb_frames_drop = 0;
218 static int input_sync;
219 static int limit_filesize = 0; //
221 static int pgmyuv_compatibility_hack=0;
222 static int dts_delta_threshold = 10;
224 static int sws_flags = SWS_BICUBIC;
226 const char **opt_names=NULL;
227 int opt_name_count=0;
228 AVCodecContext *avctx_opts;
229 AVFormatContext *avformat_opts;
231 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
232 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
233 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
235 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
237 struct AVInputStream;
239 typedef struct AVOutputStream {
240 int file_index; /* file index */
241 int index; /* stream index in the output file */
242 int source_index; /* AVInputStream index */
243 AVStream *st; /* stream in the output file */
244 int encoding_needed; /* true if encoding needed for this stream */
246 /* input pts and corresponding output pts
248 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
249 struct AVInputStream *sync_ist; /* input stream to sync against */
250 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
253 AVFrame pict_tmp; /* temporary image for resampling */
254 struct SwsContext *img_resample_ctx; /* for image resampling */
258 int topBand; /* cropping area sizes */
262 int padtop; /* padding area sizes */
269 ReSampleContext *resample; /* for audio resampling */
270 FifoBuffer fifo; /* for compression: one audio fifo per codec */
274 typedef struct AVInputStream {
278 int discard; /* true if stream data should be discarded */
279 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
280 int64_t sample_index; /* current sample */
282 int64_t start; /* time when read started */
283 unsigned long frame; /* current frame */
284 int64_t next_pts; /* synthetic pts for cases where pkt.pts
286 int64_t pts; /* current pts */
287 int is_start; /* is 1 at the start and after a discontinuity */
290 typedef struct AVInputFile {
291 int eof_reached; /* true if eof reached */
292 int ist_index; /* index of first stream in ist_table */
293 int buffer_size; /* current total buffer size */
294 int buffer_size_max; /* buffer size at which we consider we can stop
296 int nb_streams; /* nb streams we are aware of */
301 /* init terminal so that we can grab keys */
302 static struct termios oldtty;
304 static void term_exit(void)
306 tcsetattr (0, TCSANOW, &oldtty);
309 static volatile sig_atomic_t received_sigterm = 0;
312 sigterm_handler(int sig)
314 received_sigterm = sig;
318 static void term_init(void)
325 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
326 |INLCR|IGNCR|ICRNL|IXON);
327 tty.c_oflag |= OPOST;
328 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
329 tty.c_cflag &= ~(CSIZE|PARENB);
334 tcsetattr (0, TCSANOW, &tty);
336 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
337 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
338 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
340 register a function to be called at normal program termination
343 #ifdef CONFIG_BEOS_NETSERVER
344 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
348 /* read a key without blocking */
349 static int read_key(void)
353 #ifndef CONFIG_BEOS_NETSERVER
361 n = select(1, &rfds, NULL, NULL, &tv);
373 static int decode_interrupt_cb(void)
375 return q_pressed || (q_pressed = read_key() == 'q');
380 static volatile int received_sigterm = 0;
382 /* no interactive support */
383 static void term_exit(void)
387 static void term_init(void)
391 static int read_key(void)
398 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
403 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
406 /* copy stream format */
407 s->nb_streams = ic->nb_streams;
408 for(i=0;i<ic->nb_streams;i++) {
411 // FIXME: a more elegant solution is needed
412 st = av_mallocz(sizeof(AVStream));
413 memcpy(st, ic->streams[i], sizeof(AVStream));
414 st->codec = avcodec_alloc_context();
415 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
419 av_close_input_file(ic);
424 get_sync_ipts(const AVOutputStream *ost)
426 const AVInputStream *ist = ost->sync_ist;
427 return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
430 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
432 AVPacket new_pkt= *pkt;
433 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
434 &new_pkt.data, &new_pkt.size,
435 pkt->data, pkt->size,
436 pkt->flags & PKT_FLAG_KEY);
439 new_pkt.destruct= av_destruct_packet;
446 av_interleaved_write_frame(s, pkt);
449 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
451 static void do_audio_out(AVFormatContext *s,
454 unsigned char *buf, int size)
457 static uint8_t *audio_buf = NULL;
458 static uint8_t *audio_out = NULL;
459 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
461 int size_out, frame_bytes, ret;
462 AVCodecContext *enc= ost->st->codec;
464 /* SC: dynamic allocation of buffers */
466 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
468 audio_out = av_malloc(audio_out_size);
469 if (!audio_buf || !audio_out)
470 return; /* Should signal an error ! */
472 if(audio_sync_method){
473 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
474 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2);
475 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
476 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
478 //FIXME resample delay
479 if(fabs(delta) > 50){
482 byte_delta= FFMAX(byte_delta, -size);
486 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
491 static uint8_t *input_tmp= NULL;
492 input_tmp= av_realloc(input_tmp, byte_delta + size);
494 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
497 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
499 memset(input_tmp, 0, byte_delta);
500 memcpy(input_tmp + byte_delta, buf, size);
504 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
506 }else if(audio_sync_method>1){
507 int comp= clip(delta, -audio_sync_method, audio_sync_method);
508 assert(ost->audio_resample);
510 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
511 // 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));
512 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
516 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
517 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2); //FIXME wrong
519 if (ost->audio_resample) {
521 size_out = audio_resample(ost->resample,
522 (short *)buftmp, (short *)buf,
523 size / (ist->st->codec->channels * 2));
524 size_out = size_out * enc->channels * 2;
530 /* now encode as many frames as possible */
531 if (enc->frame_size > 1) {
532 /* output resampled raw samples */
533 fifo_write(&ost->fifo, buftmp, size_out,
536 frame_bytes = enc->frame_size * 2 * enc->channels;
538 while (fifo_read(&ost->fifo, audio_buf, frame_bytes,
539 &ost->fifo.rptr) == 0) {
541 av_init_packet(&pkt);
543 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
546 pkt.stream_index= ost->index;
549 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
550 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
551 pkt.flags |= PKT_FLAG_KEY;
552 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
554 ost->sync_opts += enc->frame_size;
558 av_init_packet(&pkt);
560 ost->sync_opts += size_out / (2 * enc->channels);
562 /* output a pcm frame */
563 /* XXX: change encoding codec API to avoid this ? */
564 switch(enc->codec->id) {
565 case CODEC_ID_PCM_S32LE:
566 case CODEC_ID_PCM_S32BE:
567 case CODEC_ID_PCM_U32LE:
568 case CODEC_ID_PCM_U32BE:
569 size_out = size_out << 1;
571 case CODEC_ID_PCM_S24LE:
572 case CODEC_ID_PCM_S24BE:
573 case CODEC_ID_PCM_U24LE:
574 case CODEC_ID_PCM_U24BE:
575 case CODEC_ID_PCM_S24DAUD:
576 size_out = size_out / 2 * 3;
578 case CODEC_ID_PCM_S16LE:
579 case CODEC_ID_PCM_S16BE:
580 case CODEC_ID_PCM_U16LE:
581 case CODEC_ID_PCM_U16BE:
584 size_out = size_out >> 1;
587 ret = avcodec_encode_audio(enc, audio_out, size_out,
590 pkt.stream_index= ost->index;
593 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
594 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
595 pkt.flags |= PKT_FLAG_KEY;
596 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
600 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
604 AVPicture picture_tmp;
607 dec = ist->st->codec;
609 /* deinterlace : must be done before any resize */
610 if (do_deinterlace || using_vhook) {
613 /* create temporary picture */
614 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
615 buf = av_malloc(size);
619 picture2 = &picture_tmp;
620 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
623 if(avpicture_deinterlace(picture2, picture,
624 dec->pix_fmt, dec->width, dec->height) < 0) {
625 /* if error, do not deinterlace */
631 img_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
637 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
639 if (picture != picture2)
640 *picture = *picture2;
644 /* we begin to correct av delay at this threshold */
645 #define AV_DELAY_MAX 0.100
647 static void do_subtitle_out(AVFormatContext *s,
653 static uint8_t *subtitle_out = NULL;
654 int subtitle_out_max_size = 65536;
655 int subtitle_out_size, nb, i;
659 if (pts == AV_NOPTS_VALUE) {
660 fprintf(stderr, "Subtitle packets must have a pts\n");
664 enc = ost->st->codec;
667 subtitle_out = av_malloc(subtitle_out_max_size);
670 /* Note: DVB subtitle need one packet to draw them and one other
671 packet to clear them */
672 /* XXX: signal it in the codec context ? */
673 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
678 for(i = 0; i < nb; i++) {
679 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
680 subtitle_out_max_size, sub);
682 av_init_packet(&pkt);
683 pkt.stream_index = ost->index;
684 pkt.data = subtitle_out;
685 pkt.size = subtitle_out_size;
686 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);
687 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
688 /* XXX: the pts correction is handled here. Maybe handling
689 it in the codec would be better */
691 pkt.pts += 90 * sub->start_display_time;
693 pkt.pts += 90 * sub->end_display_time;
695 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
699 static int bit_buffer_size= 1024*256;
700 static uint8_t *bit_buffer= NULL;
702 static void do_video_out(AVFormatContext *s,
708 int nb_frames, i, ret;
709 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
710 AVFrame picture_crop_temp, picture_pad_temp;
711 uint8_t *buf = NULL, *buf1 = NULL;
712 AVCodecContext *enc, *dec;
714 avcodec_get_frame_defaults(&picture_crop_temp);
715 avcodec_get_frame_defaults(&picture_pad_temp);
717 enc = ost->st->codec;
718 dec = ist->st->codec;
720 /* by default, we output a single frame */
725 if(video_sync_method){
727 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
728 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
731 else if (vdelta > 1.1)
732 nb_frames = lrintf(vdelta);
733 //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);
737 fprintf(stderr, "*** drop!\n");
738 }else if (nb_frames > 1) {
739 nb_frames_dup += nb_frames;
741 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
744 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
746 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
750 if (ost->video_crop) {
751 if (img_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
752 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
755 formatted_picture = &picture_crop_temp;
757 formatted_picture = in_picture;
760 final_picture = formatted_picture;
761 padding_src = formatted_picture;
762 resampling_dst = &ost->pict_tmp;
763 if (ost->video_pad) {
764 final_picture = &ost->pict_tmp;
765 if (ost->video_resample) {
766 if (img_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
767 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
770 resampling_dst = &picture_pad_temp;
774 if (ost->video_resample) {
776 final_picture = &ost->pict_tmp;
777 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
778 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
781 if (ost->video_pad) {
782 img_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
783 enc->height, enc->width, enc->pix_fmt,
784 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
787 /* duplicates frame if needed */
788 for(i=0;i<nb_frames;i++) {
790 av_init_packet(&pkt);
791 pkt.stream_index= ost->index;
793 if (s->oformat->flags & AVFMT_RAWPICTURE) {
794 /* raw pictures are written as AVPicture structure to
795 avoid any copies. We support temorarily the older
797 AVFrame* old_frame = enc->coded_frame;
798 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
799 pkt.data= (uint8_t *)final_picture;
800 pkt.size= sizeof(AVPicture);
801 if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
802 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
803 if(dec->coded_frame && dec->coded_frame->key_frame)
804 pkt.flags |= PKT_FLAG_KEY;
806 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
807 enc->coded_frame = old_frame;
811 big_picture= *final_picture;
812 /* better than nothing: use input picture interlaced
814 big_picture.interlaced_frame = in_picture->interlaced_frame;
815 if(avctx_opts->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
816 if(top_field_first == -1)
817 big_picture.top_field_first = in_picture->top_field_first;
819 big_picture.top_field_first = top_field_first;
822 /* handles sameq here. This is not correct because it may
823 not be a global option */
825 big_picture.quality = ist->st->quality;
827 big_picture.quality = ost->st->quality;
829 big_picture.pict_type = 0;
830 // big_picture.pts = AV_NOPTS_VALUE;
831 big_picture.pts= ost->sync_opts;
832 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
833 //av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
834 ret = avcodec_encode_video(enc,
835 bit_buffer, bit_buffer_size,
837 //enc->frame_number = enc->real_pict_num;
839 pkt.data= bit_buffer;
841 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
842 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
843 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n",
844 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
845 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
847 if(enc->coded_frame && enc->coded_frame->key_frame)
848 pkt.flags |= PKT_FLAG_KEY;
849 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
851 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
852 // enc->frame_number-1, enc->real_pict_num, ret,
854 /* if two pass, output log */
855 if (ost->logfile && enc->stats_out) {
856 fprintf(ost->logfile, "%s", enc->stats_out);
868 static double psnr(double d){
869 if(d==0) return INFINITY;
870 return -10.0*log(d)/log(10.0);
873 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
876 static FILE *fvstats=NULL;
883 double ti1, bitrate, avg_bitrate;
887 today = localtime(&today2);
888 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
891 fvstats = fopen(filename,"w");
899 enc = ost->st->codec;
900 if (enc->codec_type == CODEC_TYPE_VIDEO) {
901 frame_number = ost->frame_number;
902 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
903 if (enc->flags&CODEC_FLAG_PSNR)
904 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
906 fprintf(fvstats,"f_size= %6d ", frame_size);
907 /* compute pts value */
908 ti1 = ost->sync_opts * av_q2d(enc->time_base);
912 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
913 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
914 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
915 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
916 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
920 static void print_report(AVFormatContext **output_files,
921 AVOutputStream **ost_table, int nb_ostreams,
926 AVFormatContext *oc, *os;
929 int frame_number, vid, i;
930 double bitrate, ti1, pts;
931 static int64_t last_time = -1;
932 static int qp_histogram[52];
934 if (!is_last_report) {
936 /* display the report every 0.5 seconds */
937 cur_time = av_gettime();
938 if (last_time == -1) {
939 last_time = cur_time;
942 if ((cur_time - last_time) < 500000)
944 last_time = cur_time;
948 oc = output_files[0];
950 total_size = url_ftell(&oc->pb);
955 for(i=0;i<nb_ostreams;i++) {
957 os = output_files[ost->file_index];
958 enc = ost->st->codec;
959 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
960 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
961 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
963 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
964 frame_number = ost->frame_number;
965 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%3.1f ",
966 frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
968 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
969 if(qp_hist && enc->coded_frame){
971 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
972 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
975 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
977 if (enc->flags&CODEC_FLAG_PSNR){
979 double error, error_sum=0;
980 double scale, scale_sum=0;
981 char type[3]= {'Y','U','V'};
982 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
985 error= enc->error[j];
986 scale= enc->width*enc->height*255.0*255.0*frame_number;
988 error= enc->coded_frame->error[j];
989 scale= enc->width*enc->height*255.0*255.0;
994 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
996 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1000 /* compute min output value */
1001 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1002 if ((pts < ti1) && (pts > 0))
1008 if (verbose || is_last_report) {
1009 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1011 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1012 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1013 (double)total_size / 1024, ti1, bitrate);
1016 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1017 nb_frames_dup, nb_frames_drop);
1020 fprintf(stderr, "%s \r", buf);
1025 if (is_last_report && verbose >= 0){
1026 int64_t raw= audio_size + video_size + extra_size;
1027 fprintf(stderr, "\n");
1028 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1032 100.0*(total_size - raw)/raw
1037 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1038 static int output_packet(AVInputStream *ist, int ist_index,
1039 AVOutputStream **ost_table, int nb_ostreams,
1040 const AVPacket *pkt)
1042 AVFormatContext *os;
1043 AVOutputStream *ost;
1047 int data_size, got_picture;
1049 void *buffer_to_free;
1050 static unsigned int samples_size= 0;
1051 static short *samples= NULL;
1052 AVSubtitle subtitle, *subtitle_to_free;
1056 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1057 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1058 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1060 // assert(ist->pts == ist->next_pts);
1074 /* decode the packet if needed */
1075 data_buf = NULL; /* fail safe */
1077 subtitle_to_free = NULL;
1078 if (ist->decoding_needed) {
1079 switch(ist->st->codec->codec_type) {
1080 case CODEC_TYPE_AUDIO:{
1082 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1083 /* XXX: could avoid copy if PCM 16 bits with same
1084 endianness as CPU */
1085 ret = avcodec_decode_audio(ist->st->codec, samples, &data_size,
1091 /* Some bug in mpeg audio decoder gives */
1092 /* data_size < 0, it seems they are overflows */
1093 if (data_size <= 0) {
1094 /* no audio frame */
1097 data_buf = (uint8_t *)samples;
1098 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1099 (ist->st->codec->sample_rate * ist->st->codec->channels);
1101 case CODEC_TYPE_VIDEO:
1102 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1103 /* XXX: allocate picture correctly */
1104 avcodec_get_frame_defaults(&picture);
1106 ret = avcodec_decode_video(ist->st->codec,
1107 &picture, &got_picture, ptr, len);
1108 ist->st->quality= picture.quality;
1112 /* no picture yet */
1113 goto discard_packet;
1115 if (ist->st->codec->time_base.num != 0) {
1116 ist->next_pts += ((int64_t)AV_TIME_BASE *
1117 ist->st->codec->time_base.num) /
1118 ist->st->codec->time_base.den;
1122 case CODEC_TYPE_SUBTITLE:
1123 ret = avcodec_decode_subtitle(ist->st->codec,
1124 &subtitle, &got_subtitle, ptr, len);
1127 if (!got_subtitle) {
1128 goto discard_packet;
1130 subtitle_to_free = &subtitle;
1137 switch(ist->st->codec->codec_type) {
1138 case CODEC_TYPE_AUDIO:
1139 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1140 (ist->st->codec->sample_rate * ist->st->codec->channels);
1142 case CODEC_TYPE_VIDEO:
1143 if (ist->st->codec->time_base.num != 0) {
1144 ist->next_pts += ((int64_t)AV_TIME_BASE *
1145 ist->st->codec->time_base.num) /
1146 ist->st->codec->time_base.den;
1156 buffer_to_free = NULL;
1157 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1158 pre_process_video_frame(ist, (AVPicture *)&picture,
1162 // preprocess audio (volume)
1163 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1164 if (audio_volume != 256) {
1167 for(i=0;i<(data_size / sizeof(short));i++) {
1168 int v = ((*volp) * audio_volume + 128) >> 8;
1169 if (v < -32768) v = -32768;
1170 if (v > 32767) v = 32767;
1176 /* frame rate emulation */
1177 if (ist->st->codec->rate_emu) {
1178 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1179 int64_t now = av_gettime() - ist->start;
1187 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1188 is the one of the next displayed one */
1189 /* XXX: add mpeg4 too ? */
1190 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1191 if (ist->st->codec->pict_type != B_TYPE) {
1193 tmp = ist->last_ip_pts;
1194 ist->last_ip_pts = ist->frac_pts.val;
1195 ist->frac_pts.val = tmp;
1199 /* if output time reached then transcode raw format,
1200 encode packets and output them */
1201 if (start_time == 0 || ist->pts >= start_time)
1202 for(i=0;i<nb_ostreams;i++) {
1206 if (ost->source_index == ist_index) {
1207 os = output_files[ost->file_index];
1210 printf("%d: got pts=%0.3f %0.3f\n", i,
1211 (double)pkt->pts / AV_TIME_BASE,
1212 ((double)ist->pts / AV_TIME_BASE) -
1213 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1215 /* set the input output pts pairs */
1216 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1218 if (ost->encoding_needed) {
1219 switch(ost->st->codec->codec_type) {
1220 case CODEC_TYPE_AUDIO:
1221 do_audio_out(os, ost, ist, data_buf, data_size);
1223 case CODEC_TYPE_VIDEO:
1224 do_video_out(os, ost, ist, &picture, &frame_size);
1225 video_size += frame_size;
1226 if (do_vstats && frame_size)
1227 do_video_stats(os, ost, frame_size);
1229 case CODEC_TYPE_SUBTITLE:
1230 do_subtitle_out(os, ost, ist, &subtitle,
1237 AVFrame avframe; //FIXME/XXX remove this
1239 av_init_packet(&opkt);
1241 /* no reencoding needed : output the packet directly */
1242 /* force the input stream PTS */
1244 avcodec_get_frame_defaults(&avframe);
1245 ost->st->codec->coded_frame= &avframe;
1246 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1248 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1249 audio_size += data_size;
1250 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1251 video_size += data_size;
1255 opkt.stream_index= ost->index;
1256 if(pkt->pts != AV_NOPTS_VALUE)
1257 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);
1259 opkt.pts= AV_NOPTS_VALUE;
1263 if (pkt->dts == AV_NOPTS_VALUE)
1264 dts = ist->next_pts;
1266 dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1267 opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
1269 opkt.flags= pkt->flags;
1271 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1272 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1273 opkt.destruct= av_destruct_packet;
1275 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1276 ost->st->codec->frame_number++;
1277 ost->frame_number++;
1278 av_free_packet(&opkt);
1282 av_free(buffer_to_free);
1283 /* XXX: allocate the subtitles in the codec ? */
1284 if (subtitle_to_free) {
1285 if (subtitle_to_free->rects != NULL) {
1286 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1287 av_free(subtitle_to_free->rects[i].bitmap);
1288 av_free(subtitle_to_free->rects[i].rgba_palette);
1290 av_freep(&subtitle_to_free->rects);
1292 subtitle_to_free->num_rects = 0;
1293 subtitle_to_free = NULL;
1300 for(i=0;i<nb_ostreams;i++) {
1302 if (ost->source_index == ist_index) {
1303 AVCodecContext *enc= ost->st->codec;
1304 os = output_files[ost->file_index];
1306 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1308 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1311 if (ost->encoding_needed) {
1315 av_init_packet(&pkt);
1316 pkt.stream_index= ost->index;
1318 switch(ost->st->codec->codec_type) {
1319 case CODEC_TYPE_AUDIO:
1320 fifo_bytes = fifo_size(&ost->fifo, NULL);
1322 /* encode any samples remaining in fifo */
1323 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1324 int fs_tmp = enc->frame_size;
1325 enc->frame_size = fifo_bytes / (2 * enc->channels);
1326 if(fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes,
1327 &ost->fifo.rptr) == 0) {
1328 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1330 enc->frame_size = fs_tmp;
1333 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1336 pkt.flags |= PKT_FLAG_KEY;
1338 case CODEC_TYPE_VIDEO:
1339 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1341 if(enc->coded_frame && enc->coded_frame->key_frame)
1342 pkt.flags |= PKT_FLAG_KEY;
1343 if (ost->logfile && enc->stats_out) {
1344 fprintf(ost->logfile, "%s", enc->stats_out);
1353 pkt.data= bit_buffer;
1355 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1356 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1357 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1371 * The following code is the main loop of the file converter
1373 static int av_encode(AVFormatContext **output_files,
1374 int nb_output_files,
1375 AVFormatContext **input_files,
1377 AVStreamMap *stream_maps, int nb_stream_maps)
1379 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1380 AVFormatContext *is, *os;
1381 AVCodecContext *codec, *icodec;
1382 AVOutputStream *ost, **ost_table = NULL;
1383 AVInputStream *ist, **ist_table = NULL;
1384 AVInputFile *file_table;
1385 AVFormatContext *stream_no_data;
1388 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1392 /* input stream init */
1394 for(i=0;i<nb_input_files;i++) {
1395 is = input_files[i];
1396 file_table[i].ist_index = j;
1397 file_table[i].nb_streams = is->nb_streams;
1398 j += is->nb_streams;
1402 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1406 for(i=0;i<nb_istreams;i++) {
1407 ist = av_mallocz(sizeof(AVInputStream));
1413 for(i=0;i<nb_input_files;i++) {
1414 is = input_files[i];
1415 for(k=0;k<is->nb_streams;k++) {
1416 ist = ist_table[j++];
1417 ist->st = is->streams[k];
1418 ist->file_index = i;
1420 ist->discard = 1; /* the stream is discarded by default
1423 if (ist->st->codec->rate_emu) {
1424 ist->start = av_gettime();
1430 /* output stream init */
1432 for(i=0;i<nb_output_files;i++) {
1433 os = output_files[i];
1434 nb_ostreams += os->nb_streams;
1436 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1437 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1441 /* Sanity check the mapping args -- do the input files & streams exist? */
1442 for(i=0;i<nb_stream_maps;i++) {
1443 int fi = stream_maps[i].file_index;
1444 int si = stream_maps[i].stream_index;
1446 if (fi < 0 || fi > nb_input_files - 1 ||
1447 si < 0 || si > file_table[fi].nb_streams - 1) {
1448 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1451 fi = stream_maps[i].sync_file_index;
1452 si = stream_maps[i].sync_stream_index;
1453 if (fi < 0 || fi > nb_input_files - 1 ||
1454 si < 0 || si > file_table[fi].nb_streams - 1) {
1455 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1460 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1463 for(i=0;i<nb_ostreams;i++) {
1464 ost = av_mallocz(sizeof(AVOutputStream));
1471 for(k=0;k<nb_output_files;k++) {
1472 os = output_files[k];
1473 for(i=0;i<os->nb_streams;i++) {
1475 ost = ost_table[n++];
1476 ost->file_index = k;
1478 ost->st = os->streams[i];
1479 if (nb_stream_maps > 0) {
1480 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1481 stream_maps[n-1].stream_index;
1483 /* Sanity check that the stream types match */
1484 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1485 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1486 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1487 ost->file_index, ost->index);
1492 /* get corresponding input stream index : we select the first one with the right type */
1494 for(j=0;j<nb_istreams;j++) {
1497 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1498 ost->source_index = j;
1505 /* try again and reuse existing stream */
1506 for(j=0;j<nb_istreams;j++) {
1508 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1509 ost->source_index = j;
1514 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1515 ost->file_index, ost->index);
1520 ist = ist_table[ost->source_index];
1522 ost->sync_ist = (nb_stream_maps > 0) ?
1523 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1524 stream_maps[n-1].sync_stream_index] : ist;
1528 /* for each output stream, we compute the right encoding parameters */
1529 for(i=0;i<nb_ostreams;i++) {
1531 ist = ist_table[ost->source_index];
1533 codec = ost->st->codec;
1534 icodec = ist->st->codec;
1536 if (ost->st->stream_copy) {
1537 /* if stream_copy is selected, no need to decode or encode */
1538 codec->codec_id = icodec->codec_id;
1539 codec->codec_type = icodec->codec_type;
1540 if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1541 codec->bit_rate = icodec->bit_rate;
1542 codec->extradata= icodec->extradata;
1543 codec->extradata_size= icodec->extradata_size;
1544 codec->time_base = icodec->time_base;
1545 switch(codec->codec_type) {
1546 case CODEC_TYPE_AUDIO:
1547 codec->sample_rate = icodec->sample_rate;
1548 codec->channels = icodec->channels;
1549 codec->frame_size = icodec->frame_size;
1550 codec->block_align= icodec->block_align;
1552 case CODEC_TYPE_VIDEO:
1553 codec->pix_fmt = icodec->pix_fmt;
1554 codec->width = icodec->width;
1555 codec->height = icodec->height;
1556 codec->has_b_frames = icodec->has_b_frames;
1558 case CODEC_TYPE_SUBTITLE:
1564 switch(codec->codec_type) {
1565 case CODEC_TYPE_AUDIO:
1566 if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1569 if (codec->channels == icodec->channels &&
1570 codec->sample_rate == icodec->sample_rate) {
1571 ost->audio_resample = 0;
1573 if (codec->channels != icodec->channels &&
1574 (icodec->codec_id == CODEC_ID_AC3 ||
1575 icodec->codec_id == CODEC_ID_DTS)) {
1576 /* Special case for 5:1 AC3 and DTS input */
1577 /* and mono or stereo output */
1578 /* Request specific number of channels */
1579 icodec->channels = codec->channels;
1580 if (codec->sample_rate == icodec->sample_rate)
1581 ost->audio_resample = 0;
1583 ost->audio_resample = 1;
1586 ost->audio_resample = 1;
1589 if(audio_sync_method>1)
1590 ost->audio_resample = 1;
1592 if(ost->audio_resample){
1593 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1594 codec->sample_rate, icodec->sample_rate);
1596 printf("Can't resample. Aborting.\n");
1600 ist->decoding_needed = 1;
1601 ost->encoding_needed = 1;
1603 case CODEC_TYPE_VIDEO:
1604 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1605 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1606 ost->video_resample = ((codec->width != icodec->width -
1607 (frame_leftBand + frame_rightBand) +
1608 (frame_padleft + frame_padright)) ||
1609 (codec->height != icodec->height -
1610 (frame_topBand + frame_bottomBand) +
1611 (frame_padtop + frame_padbottom)) ||
1612 (codec->pix_fmt != icodec->pix_fmt));
1613 if (ost->video_crop) {
1614 ost->topBand = frame_topBand;
1615 ost->leftBand = frame_leftBand;
1617 if (ost->video_pad) {
1618 ost->padtop = frame_padtop;
1619 ost->padleft = frame_padleft;
1620 ost->padbottom = frame_padbottom;
1621 ost->padright = frame_padright;
1622 if (!ost->video_resample) {
1623 avcodec_get_frame_defaults(&ost->pict_tmp);
1624 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1625 codec->width, codec->height ) )
1629 if (ost->video_resample) {
1630 avcodec_get_frame_defaults(&ost->pict_tmp);
1631 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1632 codec->width, codec->height ) )
1635 ost->img_resample_ctx = sws_getContext(
1636 icodec->width - (frame_leftBand + frame_rightBand),
1637 icodec->height - (frame_topBand + frame_bottomBand),
1639 codec->width - (frame_padleft + frame_padright),
1640 codec->height - (frame_padtop + frame_padbottom),
1642 sws_flags, NULL, NULL, NULL);
1643 if (ost->img_resample_ctx == NULL) {
1644 fprintf(stderr, "Cannot get resampling context\n");
1647 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1649 ost->encoding_needed = 1;
1650 ist->decoding_needed = 1;
1652 case CODEC_TYPE_SUBTITLE:
1653 ost->encoding_needed = 1;
1654 ist->decoding_needed = 1;
1661 if (ost->encoding_needed &&
1662 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1663 char logfilename[1024];
1668 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1670 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1671 if (codec->flags & CODEC_FLAG_PASS1) {
1672 f = fopen(logfilename, "w");
1674 perror(logfilename);
1679 /* read the log file */
1680 f = fopen(logfilename, "r");
1682 perror(logfilename);
1685 fseek(f, 0, SEEK_END);
1687 fseek(f, 0, SEEK_SET);
1688 logbuffer = av_malloc(size + 1);
1690 fprintf(stderr, "Could not allocate log buffer\n");
1693 size = fread(logbuffer, 1, size, f);
1695 logbuffer[size] = '\0';
1696 codec->stats_in = logbuffer;
1700 if(codec->codec_type == CODEC_TYPE_VIDEO){
1701 int size= codec->width * codec->height;
1702 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1707 bit_buffer = av_malloc(bit_buffer_size);
1711 /* dump the file output parameters - cannot be done before in case
1713 for(i=0;i<nb_output_files;i++) {
1714 dump_format(output_files[i], i, output_files[i]->filename, 1);
1717 /* dump the stream mapping */
1719 fprintf(stderr, "Stream mapping:\n");
1720 for(i=0;i<nb_ostreams;i++) {
1722 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1723 ist_table[ost->source_index]->file_index,
1724 ist_table[ost->source_index]->index,
1727 if (ost->sync_ist != ist_table[ost->source_index])
1728 fprintf(stderr, " [sync #%d.%d]",
1729 ost->sync_ist->file_index,
1730 ost->sync_ist->index);
1731 fprintf(stderr, "\n");
1735 /* open each encoder */
1736 for(i=0;i<nb_ostreams;i++) {
1738 if (ost->encoding_needed) {
1740 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1742 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1743 ost->file_index, ost->index);
1746 if (avcodec_open(ost->st->codec, codec) < 0) {
1747 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1748 ost->file_index, ost->index);
1751 extra_size += ost->st->codec->extradata_size;
1755 /* open each decoder */
1756 for(i=0;i<nb_istreams;i++) {
1758 if (ist->decoding_needed) {
1760 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1762 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1763 ist->st->codec->codec_id, ist->file_index, ist->index);
1766 if (avcodec_open(ist->st->codec, codec) < 0) {
1767 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1768 ist->file_index, ist->index);
1771 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1772 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1777 for(i=0;i<nb_istreams;i++) {
1779 is = input_files[ist->file_index];
1781 ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1782 if(ist->st->start_time == AV_NOPTS_VALUE)
1784 if(input_files_ts_offset[ist->file_index])
1785 ist->next_pts= AV_NOPTS_VALUE;
1789 /* compute buffer size max (should use a complete heuristic) */
1790 for(i=0;i<nb_input_files;i++) {
1791 file_table[i].buffer_size_max = 2048;
1794 /* set meta data information from input file if required */
1795 for (i=0;i<nb_meta_data_maps;i++) {
1796 AVFormatContext *out_file;
1797 AVFormatContext *in_file;
1799 int out_file_index = meta_data_maps[i].out_file;
1800 int in_file_index = meta_data_maps[i].in_file;
1801 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1802 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1806 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1807 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1812 out_file = output_files[out_file_index];
1813 in_file = input_files[in_file_index];
1815 strcpy(out_file->title, in_file->title);
1816 strcpy(out_file->author, in_file->author);
1817 strcpy(out_file->copyright, in_file->copyright);
1818 strcpy(out_file->comment, in_file->comment);
1819 strcpy(out_file->album, in_file->album);
1820 out_file->year = in_file->year;
1821 out_file->track = in_file->track;
1822 strcpy(out_file->genre, in_file->genre);
1825 /* open files and write file headers */
1826 for(i=0;i<nb_output_files;i++) {
1827 os = output_files[i];
1828 if (av_write_header(os) < 0) {
1829 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1836 if ( !using_stdin && verbose >= 0) {
1837 fprintf(stderr, "Press [q] to stop encoding\n");
1838 url_set_interrupt_cb(decode_interrupt_cb);
1846 for(; received_sigterm == 0;) {
1847 int file_index, ist_index;
1855 /* if 'q' pressed, exits */
1859 /* read_key() returns 0 on EOF */
1865 /* select the stream that we must read now by looking at the
1866 smallest output pts */
1868 for(i=0;i<nb_ostreams;i++) {
1871 os = output_files[ost->file_index];
1872 ist = ist_table[ost->source_index];
1873 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1874 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1876 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1877 ipts = (double)ist->pts;
1878 if (!file_table[ist->file_index].eof_reached){
1879 if(ipts < ipts_min) {
1881 if(input_sync ) file_index = ist->file_index;
1883 if(opts < opts_min) {
1885 if(!input_sync) file_index = ist->file_index;
1888 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1893 /* if none, if is finished */
1894 if (file_index < 0) {
1898 /* finish if recording time exhausted */
1899 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1902 /* finish if limit size exhausted */
1903 if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1906 /* read a frame from it and output it in the fifo */
1907 is = input_files[file_index];
1908 if (av_read_frame(is, &pkt) < 0) {
1909 file_table[file_index].eof_reached = 1;
1910 if (opt_shortest) break; else continue; //
1914 stream_no_data = is;
1919 av_pkt_dump(stdout, &pkt, do_hex_dump);
1921 /* the following test is needed in case new streams appear
1922 dynamically in stream : we ignore them */
1923 if (pkt.stream_index >= file_table[file_index].nb_streams)
1924 goto discard_packet;
1925 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1926 ist = ist_table[ist_index];
1928 goto discard_packet;
1930 // 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);
1931 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1932 int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1933 if(ABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1934 input_files_ts_offset[ist->file_index]-= delta;
1936 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1937 for(i=0; i<file_table[file_index].nb_streams; i++){
1938 int index= file_table[file_index].ist_index + i;
1939 ist_table[index]->next_pts += delta;
1940 ist_table[index]->is_start=1;
1945 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1946 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1949 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1950 ist->file_index, ist->index);
1952 av_free_packet(&pkt);
1957 av_free_packet(&pkt);
1959 /* dump report by using the output first video and audio streams */
1960 print_report(output_files, ost_table, nb_ostreams, 0);
1963 /* at the end of stream, we must flush the decoder buffers */
1964 for(i=0;i<nb_istreams;i++) {
1966 if (ist->decoding_needed) {
1967 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1973 /* write the trailer if needed and close file */
1974 for(i=0;i<nb_output_files;i++) {
1975 os = output_files[i];
1976 av_write_trailer(os);
1979 /* dump report by using the first video and audio streams */
1980 print_report(output_files, ost_table, nb_ostreams, 1);
1982 /* close each encoder */
1983 for(i=0;i<nb_ostreams;i++) {
1985 if (ost->encoding_needed) {
1986 av_freep(&ost->st->codec->stats_in);
1987 avcodec_close(ost->st->codec);
1991 /* close each decoder */
1992 for(i=0;i<nb_istreams;i++) {
1994 if (ist->decoding_needed) {
1995 avcodec_close(ist->st->codec);
2003 av_freep(&bit_buffer);
2004 av_free(file_table);
2007 for(i=0;i<nb_istreams;i++) {
2014 for(i=0;i<nb_ostreams;i++) {
2018 fclose(ost->logfile);
2019 ost->logfile = NULL;
2021 fifo_free(&ost->fifo); /* works even if fifo is not
2022 initialized but set to zero */
2023 av_free(ost->pict_tmp.data[0]);
2024 if (ost->video_resample)
2025 sws_freeContext(ost->img_resample_ctx);
2026 if (ost->audio_resample)
2027 audio_resample_close(ost->resample);
2040 int file_read(const char *filename)
2043 unsigned char buffer[1024];
2046 if (url_open(&h, filename, O_RDONLY) < 0) {
2047 printf("could not open '%s'\n", filename);
2051 len = url_read(h, buffer, sizeof(buffer));
2054 for(i=0;i<len;i++) putchar(buffer[i]);
2061 static void opt_image_format(const char *arg)
2065 for(f = first_image_format; f != NULL; f = f->next) {
2066 if (!strcmp(arg, f->name))
2070 fprintf(stderr, "Unknown image format: '%s'\n", arg);
2076 static void opt_format(const char *arg)
2078 /* compatibility stuff for pgmyuv */
2079 if (!strcmp(arg, "pgmyuv")) {
2080 pgmyuv_compatibility_hack=1;
2081 // opt_image_format(arg);
2085 file_iformat = av_find_input_format(arg);
2086 file_oformat = guess_format(arg, NULL, NULL);
2087 if (!file_iformat && !file_oformat) {
2088 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2093 static void opt_video_rc_eq(char *arg)
2098 static void opt_video_rc_override_string(char *arg)
2100 video_rc_override_string = arg;
2103 static void opt_me_threshold(const char *arg)
2105 me_threshold = atoi(arg);
2108 static void opt_mb_threshold(const char *arg)
2110 mb_threshold = atoi(arg);
2113 static void opt_verbose(const char *arg)
2115 verbose = atoi(arg);
2116 av_log_set_level(atoi(arg));
2119 static void opt_frame_rate(const char *arg)
2121 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2122 fprintf(stderr, "Incorrect frame rate\n");
2127 static void opt_frame_crop_top(const char *arg)
2129 frame_topBand = atoi(arg);
2130 if (frame_topBand < 0) {
2131 fprintf(stderr, "Incorrect top crop size\n");
2134 if ((frame_topBand % 2) != 0) {
2135 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2138 if ((frame_topBand) >= frame_height){
2139 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2142 frame_height -= frame_topBand;
2145 static void opt_frame_crop_bottom(const char *arg)
2147 frame_bottomBand = atoi(arg);
2148 if (frame_bottomBand < 0) {
2149 fprintf(stderr, "Incorrect bottom crop size\n");
2152 if ((frame_bottomBand % 2) != 0) {
2153 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2156 if ((frame_bottomBand) >= frame_height){
2157 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2160 frame_height -= frame_bottomBand;
2163 static void opt_frame_crop_left(const char *arg)
2165 frame_leftBand = atoi(arg);
2166 if (frame_leftBand < 0) {
2167 fprintf(stderr, "Incorrect left crop size\n");
2170 if ((frame_leftBand % 2) != 0) {
2171 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2174 if ((frame_leftBand) >= frame_width){
2175 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2178 frame_width -= frame_leftBand;
2181 static void opt_frame_crop_right(const char *arg)
2183 frame_rightBand = atoi(arg);
2184 if (frame_rightBand < 0) {
2185 fprintf(stderr, "Incorrect right crop size\n");
2188 if ((frame_rightBand % 2) != 0) {
2189 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2192 if ((frame_rightBand) >= frame_width){
2193 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2196 frame_width -= frame_rightBand;
2199 static void opt_frame_size(const char *arg)
2201 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2202 fprintf(stderr, "Incorrect frame size\n");
2205 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2206 fprintf(stderr, "Frame size must be a multiple of 2\n");
2212 #define SCALEBITS 10
2213 #define ONE_HALF (1 << (SCALEBITS - 1))
2214 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2216 #define RGB_TO_Y(r, g, b) \
2217 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2218 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2220 #define RGB_TO_U(r1, g1, b1, shift)\
2221 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2222 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2224 #define RGB_TO_V(r1, g1, b1, shift)\
2225 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2226 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2228 static void opt_pad_color(const char *arg) {
2229 /* Input is expected to be six hex digits similar to
2230 how colors are expressed in html tags (but without the #) */
2231 int rgb = strtol(arg, NULL, 16);
2235 g = ((rgb >> 8) & 255);
2238 padcolor[0] = RGB_TO_Y(r,g,b);
2239 padcolor[1] = RGB_TO_U(r,g,b,0);
2240 padcolor[2] = RGB_TO_V(r,g,b,0);
2243 static void opt_frame_pad_top(const char *arg)
2245 frame_padtop = atoi(arg);
2246 if (frame_padtop < 0) {
2247 fprintf(stderr, "Incorrect top pad size\n");
2250 if ((frame_padtop % 2) != 0) {
2251 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2256 static void opt_frame_pad_bottom(const char *arg)
2258 frame_padbottom = atoi(arg);
2259 if (frame_padbottom < 0) {
2260 fprintf(stderr, "Incorrect bottom pad size\n");
2263 if ((frame_padbottom % 2) != 0) {
2264 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2270 static void opt_frame_pad_left(const char *arg)
2272 frame_padleft = atoi(arg);
2273 if (frame_padleft < 0) {
2274 fprintf(stderr, "Incorrect left pad size\n");
2277 if ((frame_padleft % 2) != 0) {
2278 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2284 static void opt_frame_pad_right(const char *arg)
2286 frame_padright = atoi(arg);
2287 if (frame_padright < 0) {
2288 fprintf(stderr, "Incorrect right pad size\n");
2291 if ((frame_padright % 2) != 0) {
2292 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2298 static void opt_frame_pix_fmt(const char *arg)
2300 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2303 static void opt_frame_aspect_ratio(const char *arg)
2309 p = strchr(arg, ':');
2311 x = strtol(arg, (char **)&arg, 10);
2313 y = strtol(arg+1, (char **)&arg, 10);
2315 ar = (double)x / (double)y;
2317 ar = strtod(arg, (char **)&arg);
2320 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2323 frame_aspect_ratio = ar;
2326 static void opt_qscale(const char *arg)
2328 video_qscale = atof(arg);
2329 if (video_qscale <= 0 ||
2330 video_qscale > 255) {
2331 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2336 static void opt_lmax(const char *arg)
2338 video_lmax = atof(arg)*FF_QP2LAMBDA;
2341 static void opt_lmin(const char *arg)
2343 video_lmin = atof(arg)*FF_QP2LAMBDA;
2346 static void opt_mb_lmin(const char *arg)
2348 video_mb_lmin = atof(arg)*FF_QP2LAMBDA;
2349 if (video_mb_lmin < 1 ||
2350 video_mb_lmin > FF_LAMBDA_MAX) {
2351 fprintf(stderr, "mblmin must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2356 static void opt_mb_lmax(const char *arg)
2358 video_mb_lmax = atof(arg)*FF_QP2LAMBDA;
2359 if (video_mb_lmax < 1 ||
2360 video_mb_lmax > FF_LAMBDA_MAX) {
2361 fprintf(stderr, "mblmax must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2366 static void opt_qdiff(const char *arg)
2368 video_qdiff = atoi(arg);
2369 if (video_qdiff < 0 ||
2371 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2376 static void opt_packet_size(const char *arg)
2378 packet_size= atoi(arg);
2381 static void opt_error_rate(const char *arg)
2383 error_rate= atoi(arg);
2386 static void opt_strict(const char *arg)
2391 static void opt_top_field_first(const char *arg)
2393 top_field_first= atoi(arg);
2396 static void opt_thread_count(const char *arg)
2398 thread_count= atoi(arg);
2399 #if !defined(HAVE_THREADS)
2401 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2405 static void opt_audio_bitrate(const char *arg)
2407 audio_bit_rate = atoi(arg) * 1000;
2410 static void opt_audio_rate(const char *arg)
2412 audio_sample_rate = atoi(arg);
2415 static void opt_audio_channels(const char *arg)
2417 audio_channels = atoi(arg);
2420 static void opt_video_device(const char *arg)
2422 video_device = av_strdup(arg);
2425 static void opt_grab_device(const char *arg)
2427 grab_device = av_strdup(arg);
2430 static void opt_video_channel(const char *arg)
2432 video_channel = strtol(arg, NULL, 0);
2435 static void opt_video_standard(const char *arg)
2437 video_standard = av_strdup(arg);
2440 static void opt_audio_device(const char *arg)
2442 audio_device = av_strdup(arg);
2445 static void opt_codec(int *pstream_copy, int *pcodec_id,
2446 int codec_type, const char *arg)
2450 if (!strcmp(arg, "copy")) {
2455 if (!strcmp(p->name, arg) && p->type == codec_type)
2460 fprintf(stderr, "Unknown codec '%s'\n", arg);
2468 static void opt_audio_codec(const char *arg)
2470 opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2473 static void opt_audio_tag(const char *arg)
2476 audio_codec_tag= strtol(arg, &tail, 0);
2479 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2482 static void opt_video_tag(const char *arg)
2485 video_codec_tag= strtol(arg, &tail, 0);
2488 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2491 static void add_frame_hooker(const char *arg)
2496 char *args = av_strdup(arg);
2500 argv[0] = strtok(args, " ");
2501 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2504 i = frame_hook_add(argc, argv);
2507 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2512 const char *motion_str[] = {
2525 static void opt_motion_estimation(const char *arg)
2531 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2534 if (!strcmp(*p, arg))
2538 me_method = (p - motion_str) + 1;
2541 static void opt_video_codec(const char *arg)
2543 opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2546 static void opt_subtitle_codec(const char *arg)
2548 opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2551 static void opt_map(const char *arg)
2557 m = &stream_maps[nb_stream_maps++];
2559 m->file_index = strtol(arg, (char **)&p, 0);
2563 m->stream_index = strtol(p, (char **)&p, 0);
2566 m->sync_file_index = strtol(p, (char **)&p, 0);
2569 m->sync_stream_index = strtol(p, (char **)&p, 0);
2571 m->sync_file_index = m->file_index;
2572 m->sync_stream_index = m->stream_index;
2576 static void opt_map_meta_data(const char *arg)
2582 m = &meta_data_maps[nb_meta_data_maps++];
2584 m->out_file = strtol(arg, (char **)&p, 0);
2588 m->in_file = strtol(p, (char **)&p, 0);
2591 static void opt_recording_time(const char *arg)
2593 recording_time = parse_date(arg, 1);
2596 static void opt_start_time(const char *arg)
2598 start_time = parse_date(arg, 1);
2601 static void opt_rec_timestamp(const char *arg)
2603 rec_timestamp = parse_date(arg, 0) / 1000000;
2606 static void opt_input_ts_offset(const char *arg)
2608 input_ts_offset = parse_date(arg, 1);
2611 static void opt_input_file(const char *filename)
2613 AVFormatContext *ic;
2614 AVFormatParameters params, *ap = ¶ms;
2615 int err, i, ret, rfps, rfps_base;
2618 if (!strcmp(filename, "-"))
2621 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2622 !strcmp( filename, "/dev/stdin" );
2624 /* get default parameters from command line */
2625 ic = av_alloc_format_context();
2627 memset(ap, 0, sizeof(*ap));
2628 ap->prealloced_context = 1;
2629 ap->sample_rate = audio_sample_rate;
2630 ap->channels = audio_channels;
2631 ap->time_base.den = frame_rate;
2632 ap->time_base.num = frame_rate_base;
2633 ap->width = frame_width + frame_padleft + frame_padright;
2634 ap->height = frame_height + frame_padtop + frame_padbottom;
2635 ap->image_format = image_format;
2636 ap->pix_fmt = frame_pix_fmt;
2637 ap->device = grab_device;
2638 ap->channel = video_channel;
2639 ap->standard = video_standard;
2640 ap->video_codec_id = video_codec_id;
2641 ap->audio_codec_id = audio_codec_id;
2642 if(pgmyuv_compatibility_hack)
2643 ap->video_codec_id= CODEC_ID_PGMYUV;
2645 for(i=0; i<opt_name_count; i++){
2647 double d= av_get_double(avformat_opts, opt_names[i], &opt);
2648 if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2649 av_set_double(ic, opt_names[i], d);
2651 /* open the input file with generic libav function */
2652 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2654 print_error(filename, err);
2658 ic->loop_input = loop_input;
2660 /* If not enough info to get the stream parameters, we decode the
2661 first frames to get it. (used in mpeg case for example) */
2662 ret = av_find_stream_info(ic);
2663 if (ret < 0 && verbose >= 0) {
2664 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2668 timestamp = start_time;
2669 /* add the stream start time */
2670 if (ic->start_time != AV_NOPTS_VALUE)
2671 timestamp += ic->start_time;
2673 /* if seeking requested, we execute it */
2674 if (start_time != 0) {
2675 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2677 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2678 filename, (double)timestamp / AV_TIME_BASE);
2680 /* reset seek info */
2684 /* update the current parameters so that they match the one of the input stream */
2685 for(i=0;i<ic->nb_streams;i++) {
2687 AVCodecContext *enc = ic->streams[i]->codec;
2688 #if defined(HAVE_THREADS)
2690 avcodec_thread_init(enc, thread_count);
2692 enc->thread_count= thread_count;
2693 switch(enc->codec_type) {
2694 case CODEC_TYPE_AUDIO:
2695 for(j=0; j<opt_name_count; j++){
2697 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2698 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2699 av_set_double(enc, opt_names[j], d);
2701 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2702 audio_channels = enc->channels;
2703 audio_sample_rate = enc->sample_rate;
2705 ic->streams[i]->discard= AVDISCARD_ALL;
2707 case CODEC_TYPE_VIDEO:
2708 for(j=0; j<opt_name_count; j++){
2710 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2711 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2712 av_set_double(enc, opt_names[j], d);
2714 frame_height = enc->height;
2715 frame_width = enc->width;
2716 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2717 frame_pix_fmt = enc->pix_fmt;
2718 rfps = ic->streams[i]->r_frame_rate.num;
2719 rfps_base = ic->streams[i]->r_frame_rate.den;
2720 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2722 enc->debug |= FF_DEBUG_MV;
2724 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2727 fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2728 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2730 (float)rfps / rfps_base, rfps, rfps_base);
2732 /* update the current frame rate to match the stream frame rate */
2734 frame_rate_base = rfps_base;
2736 enc->rate_emu = rate_emu;
2738 ic->streams[i]->discard= AVDISCARD_ALL;
2739 else if(video_discard)
2740 ic->streams[i]->discard= video_discard;
2742 case CODEC_TYPE_DATA:
2744 case CODEC_TYPE_SUBTITLE:
2746 case CODEC_TYPE_UNKNOWN:
2753 input_files[nb_input_files] = ic;
2754 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2755 /* dump the file content */
2757 dump_format(ic, nb_input_files, filename, 0);
2760 file_iformat = NULL;
2761 file_oformat = NULL;
2762 image_format = NULL;
2770 static void opt_grab(const char *arg)
2772 file_iformat = av_find_input_format(arg);
2776 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2778 int has_video, has_audio, i, j;
2779 AVFormatContext *ic;
2783 for(j=0;j<nb_input_files;j++) {
2784 ic = input_files[j];
2785 for(i=0;i<ic->nb_streams;i++) {
2786 AVCodecContext *enc = ic->streams[i]->codec;
2787 switch(enc->codec_type) {
2788 case CODEC_TYPE_AUDIO:
2791 case CODEC_TYPE_VIDEO:
2794 case CODEC_TYPE_DATA:
2795 case CODEC_TYPE_UNKNOWN:
2796 case CODEC_TYPE_SUBTITLE:
2803 *has_video_ptr = has_video;
2804 *has_audio_ptr = has_audio;
2807 static void new_video_stream(AVFormatContext *oc)
2810 AVCodecContext *video_enc;
2813 st = av_new_stream(oc, oc->nb_streams);
2815 fprintf(stderr, "Could not alloc stream\n");
2818 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2819 video_bitstream_filters= NULL;
2821 #if defined(HAVE_THREADS)
2823 avcodec_thread_init(st->codec, thread_count);
2826 video_enc = st->codec;
2829 video_enc->codec_tag= video_codec_tag;
2831 if( (video_global_header&1)
2832 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2833 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2834 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2836 if(video_global_header&2){
2837 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2838 avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2841 if (video_stream_copy) {
2842 st->stream_copy = 1;
2843 video_enc->codec_type = CODEC_TYPE_VIDEO;
2849 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2850 if (video_codec_id != CODEC_ID_NONE)
2851 codec_id = video_codec_id;
2853 video_enc->codec_id = codec_id;
2854 codec = avcodec_find_encoder(codec_id);
2856 for(i=0; i<opt_name_count; i++){
2858 double d= av_get_double(avctx_opts, opt_names[i], &opt);
2859 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2860 av_set_double(video_enc, opt_names[i], d);
2863 video_enc->time_base.den = frame_rate;
2864 video_enc->time_base.num = frame_rate_base;
2865 if(codec && codec->supported_framerates){
2866 const AVRational *p= codec->supported_framerates;
2867 AVRational req= (AVRational){frame_rate, frame_rate_base};
2868 const AVRational *best=NULL;
2869 AVRational best_error= (AVRational){INT_MAX, 1};
2870 for(; p->den!=0; p++){
2871 AVRational error= av_sub_q(req, *p);
2872 if(error.num <0) error.num *= -1;
2873 if(av_cmp_q(error, best_error) < 0){
2878 video_enc->time_base.den= best->num;
2879 video_enc->time_base.num= best->den;
2882 video_enc->width = frame_width + frame_padright + frame_padleft;
2883 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2884 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2885 video_enc->pix_fmt = frame_pix_fmt;
2887 if(codec && codec->pix_fmts){
2888 const enum PixelFormat *p= codec->pix_fmts;
2890 if(*p == video_enc->pix_fmt)
2894 video_enc->pix_fmt = codec->pix_fmts[0];
2898 video_enc->gop_size = 0;
2899 if (video_qscale || same_quality) {
2900 video_enc->flags |= CODEC_FLAG_QSCALE;
2901 video_enc->global_quality=
2902 st->quality = FF_QP2LAMBDA * video_qscale;
2906 video_enc->intra_matrix = intra_matrix;
2908 video_enc->inter_matrix = inter_matrix;
2910 video_enc->lmin = video_lmin;
2911 video_enc->lmax = video_lmax;
2912 video_enc->mb_lmin = video_mb_lmin;
2913 video_enc->mb_lmax = video_mb_lmax;
2914 video_enc->max_qdiff = video_qdiff;
2915 video_enc->rc_eq = video_rc_eq;
2916 video_enc->thread_count = thread_count;
2917 p= video_rc_override_string;
2920 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2922 fprintf(stderr, "error parsing rc_override\n");
2925 video_enc->rc_override=
2926 av_realloc(video_enc->rc_override,
2927 sizeof(RcOverride)*(i+1));
2928 video_enc->rc_override[i].start_frame= start;
2929 video_enc->rc_override[i].end_frame = end;
2931 video_enc->rc_override[i].qscale= q;
2932 video_enc->rc_override[i].quality_factor= 1.0;
2935 video_enc->rc_override[i].qscale= 0;
2936 video_enc->rc_override[i].quality_factor= -q/100.0;
2941 video_enc->rc_override_count=i;
2942 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2943 video_enc->me_threshold= me_threshold;
2944 video_enc->mb_threshold= mb_threshold;
2945 video_enc->intra_dc_precision= intra_dc_precision - 8;
2946 video_enc->strict_std_compliance = strict;
2947 video_enc->error_rate = error_rate;
2948 video_enc->me_penalty_compensation= me_penalty_compensation;
2949 video_enc->frame_skip_threshold= frame_skip_threshold;
2950 video_enc->frame_skip_factor= frame_skip_factor;
2951 video_enc->frame_skip_exp= frame_skip_exp;
2954 video_enc->rtp_mode= 1;
2955 video_enc->rtp_payload_size= packet_size;
2959 video_enc->flags|= CODEC_FLAG_PSNR;
2961 video_enc->me_method = me_method;
2966 video_enc->flags |= CODEC_FLAG_PASS1;
2968 video_enc->flags |= CODEC_FLAG_PASS2;
2973 /* reset some key parameters */
2975 video_codec_id = CODEC_ID_NONE;
2976 video_stream_copy = 0;
2979 static void new_audio_stream(AVFormatContext *oc)
2982 AVCodecContext *audio_enc;
2985 st = av_new_stream(oc, oc->nb_streams);
2987 fprintf(stderr, "Could not alloc stream\n");
2991 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2992 audio_bitstream_filters= NULL;
2994 #if defined(HAVE_THREADS)
2996 avcodec_thread_init(st->codec, thread_count);
2999 audio_enc = st->codec;
3000 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3003 audio_enc->codec_tag= audio_codec_tag;
3005 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3006 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3007 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
3009 if (audio_stream_copy) {
3010 st->stream_copy = 1;
3011 audio_enc->channels = audio_channels;
3013 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3015 for(i=0; i<opt_name_count; i++){
3017 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3018 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3019 av_set_double(audio_enc, opt_names[i], d);
3022 if (audio_codec_id != CODEC_ID_NONE)
3023 codec_id = audio_codec_id;
3024 audio_enc->codec_id = codec_id;
3026 audio_enc->bit_rate = audio_bit_rate;
3027 if (audio_qscale > QSCALE_NONE) {
3028 audio_enc->flags |= CODEC_FLAG_QSCALE;
3029 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3031 audio_enc->strict_std_compliance = strict;
3032 audio_enc->thread_count = thread_count;
3033 /* For audio codecs other than AC3 or DTS we limit */
3034 /* the number of coded channels to stereo */
3035 if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3036 && codec_id != CODEC_ID_DTS) {
3037 audio_enc->channels = 2;
3039 audio_enc->channels = audio_channels;
3041 audio_enc->sample_rate = audio_sample_rate;
3042 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3043 if (audio_language) {
3044 pstrcpy(st->language, sizeof(st->language), audio_language);
3045 av_free(audio_language);
3046 audio_language = NULL;
3049 /* reset some key parameters */
3051 audio_codec_id = CODEC_ID_NONE;
3052 audio_stream_copy = 0;
3055 static void opt_new_subtitle_stream(void)
3057 AVFormatContext *oc;
3059 AVCodecContext *subtitle_enc;
3062 if (nb_output_files <= 0) {
3063 fprintf(stderr, "At least one output file must be specified\n");
3066 oc = output_files[nb_output_files - 1];
3068 st = av_new_stream(oc, oc->nb_streams);
3070 fprintf(stderr, "Could not alloc stream\n");
3074 subtitle_enc = st->codec;
3075 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3076 if (subtitle_stream_copy) {
3077 st->stream_copy = 1;
3079 for(i=0; i<opt_name_count; i++){
3081 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3082 if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3083 av_set_double(subtitle_enc, opt_names[i], d);
3085 subtitle_enc->codec_id = subtitle_codec_id;
3088 if (subtitle_language) {
3089 pstrcpy(st->language, sizeof(st->language), subtitle_language);
3090 av_free(subtitle_language);
3091 subtitle_language = NULL;
3094 subtitle_codec_id = CODEC_ID_NONE;
3095 subtitle_stream_copy = 0;
3098 static void opt_new_audio_stream(void)
3100 AVFormatContext *oc;
3101 if (nb_output_files <= 0) {
3102 fprintf(stderr, "At least one output file must be specified\n");
3105 oc = output_files[nb_output_files - 1];
3106 new_audio_stream(oc);
3109 static void opt_new_video_stream(void)
3111 AVFormatContext *oc;
3112 if (nb_output_files <= 0) {
3113 fprintf(stderr, "At least one output file must be specified\n");
3116 oc = output_files[nb_output_files - 1];
3117 new_video_stream(oc);
3120 static void opt_output_file(const char *filename)
3122 AVFormatContext *oc;
3123 int use_video, use_audio, input_has_video, input_has_audio, i;
3124 AVFormatParameters params, *ap = ¶ms;
3126 if (!strcmp(filename, "-"))
3129 oc = av_alloc_format_context();
3131 if (!file_oformat) {
3132 file_oformat = guess_format(NULL, filename, NULL);
3133 if (!file_oformat) {
3134 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3140 oc->oformat = file_oformat;
3141 pstrcpy(oc->filename, sizeof(oc->filename), filename);
3143 if (!strcmp(file_oformat->name, "ffm") &&
3144 strstart(filename, "http:", NULL)) {
3145 /* special case for files sent to ffserver: we get the stream
3146 parameters from ffserver */
3147 if (read_ffserver_streams(oc, filename) < 0) {
3148 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3152 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3153 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3155 /* disable if no corresponding type found and at least one
3157 if (nb_input_files > 0) {
3158 check_audio_video_inputs(&input_has_video, &input_has_audio);
3159 if (!input_has_video)
3161 if (!input_has_audio)
3165 /* manual disable */
3166 if (audio_disable) {
3169 if (video_disable) {
3174 new_video_stream(oc);
3178 new_audio_stream(oc);
3181 if (!oc->nb_streams) {
3182 fprintf(stderr, "No audio or video streams available\n");
3186 oc->timestamp = rec_timestamp;
3189 pstrcpy(oc->title, sizeof(oc->title), str_title);
3191 pstrcpy(oc->author, sizeof(oc->author), str_author);
3193 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3195 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3197 pstrcpy(oc->album, sizeof(oc->album), str_album);
3200 output_files[nb_output_files++] = oc;
3202 /* check filename in case of an image number is expected */
3203 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3204 if (!av_filename_number_test(oc->filename)) {
3205 print_error(oc->filename, AVERROR_NUMEXPECTED);
3210 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3211 /* test if it already exists to avoid loosing precious files */
3212 if (!file_overwrite &&
3213 (strchr(filename, ':') == NULL ||
3214 strstart(filename, "file:", NULL))) {
3215 if (url_exist(filename)) {
3218 if ( !using_stdin ) {
3219 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3222 if (toupper(c) != 'Y') {
3223 fprintf(stderr, "Not overwriting - exiting\n");
3228 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3235 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3236 fprintf(stderr, "Could not open '%s'\n", filename);
3241 memset(ap, 0, sizeof(*ap));
3242 ap->image_format = image_format;
3243 if (av_set_parameters(oc, ap) < 0) {
3244 fprintf(stderr, "%s: Invalid encoding parameters\n",
3249 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3250 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3251 oc->loop_output = loop_output;
3253 for(i=0; i<opt_name_count; i++){
3255 double d = av_get_double(avformat_opts, opt_names[i], &opt);
3256 if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3257 av_set_double(oc, opt_names[i], d);
3260 /* reset some options */
3261 file_oformat = NULL;
3262 file_iformat = NULL;
3263 image_format = NULL;
3266 /* prepare dummy protocols for grab */
3267 static void prepare_grab(void)
3269 int has_video, has_audio, i, j;
3270 AVFormatContext *oc;
3271 AVFormatContext *ic;
3272 AVFormatParameters vp1, *vp = &vp1;
3273 AVFormatParameters ap1, *ap = &ap1;
3275 /* see if audio/video inputs are needed */
3278 memset(ap, 0, sizeof(*ap));
3279 memset(vp, 0, sizeof(*vp));
3280 vp->time_base.num= 1;
3281 for(j=0;j<nb_output_files;j++) {
3282 oc = output_files[j];
3283 for(i=0;i<oc->nb_streams;i++) {
3284 AVCodecContext *enc = oc->streams[i]->codec;
3285 switch(enc->codec_type) {
3286 case CODEC_TYPE_AUDIO:
3287 if (enc->sample_rate > ap->sample_rate)
3288 ap->sample_rate = enc->sample_rate;
3289 if (enc->channels > ap->channels)
3290 ap->channels = enc->channels;
3293 case CODEC_TYPE_VIDEO:
3294 if (enc->width > vp->width)
3295 vp->width = enc->width;
3296 if (enc->height > vp->height)
3297 vp->height = enc->height;
3299 if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3300 vp->time_base = enc->time_base;
3301 vp->width += frame_leftBand + frame_rightBand;
3302 vp->width -= (frame_padleft + frame_padright);
3303 vp->height += frame_topBand + frame_bottomBand;
3304 vp->height -= (frame_padtop + frame_padbottom);
3314 if (has_video == 0 && has_audio == 0) {
3315 fprintf(stderr, "Output file must have at least one audio or video stream\n");
3320 AVInputFormat *fmt1;
3321 fmt1 = av_find_input_format(video_grab_format);
3322 vp->device = video_device;
3323 vp->channel = video_channel;
3324 vp->standard = video_standard;
3325 vp->pix_fmt = frame_pix_fmt;
3326 if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3327 fprintf(stderr, "Could not find video grab device\n");
3330 /* If not enough info to get the stream parameters, we decode the
3331 first frames to get it. */
3332 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3333 fprintf(stderr, "Could not find video grab parameters\n");
3336 /* by now video grab has one stream */
3337 ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3338 ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3339 input_files[nb_input_files] = ic;
3342 dump_format(ic, nb_input_files, "", 0);
3346 if (has_audio && audio_grab_format) {
3347 AVInputFormat *fmt1;
3348 fmt1 = av_find_input_format(audio_grab_format);
3349 ap->device = audio_device;
3350 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3351 fprintf(stderr, "Could not find audio grab device\n");
3354 input_files[nb_input_files] = ic;
3357 dump_format(ic, nb_input_files, "", 0);
3363 /* same option as mencoder */
3364 static void opt_pass(const char *pass_str)
3367 pass = atoi(pass_str);
3368 if (pass != 1 && pass != 2) {
3369 fprintf(stderr, "pass number can be only 1 or 2\n");
3375 #if defined(__MINGW32__) || defined(CONFIG_OS2)
3376 static int64_t getutime(void)
3378 return av_gettime();
3381 static int64_t getutime(void)
3383 struct rusage rusage;
3385 getrusage(RUSAGE_SELF, &rusage);
3386 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3390 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3391 extern int ffm_nopts;
3394 static void show_formats(void)
3396 AVInputFormat *ifmt;
3397 AVOutputFormat *ofmt;
3398 AVImageFormat *image_fmt;
3401 const char **pp, *last_name;
3403 printf("File formats:\n");
3408 const char *name=NULL;
3409 const char *long_name=NULL;
3411 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3412 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3413 strcmp(ofmt->name, last_name)>0){
3415 long_name= ofmt->long_name;
3419 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3420 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3421 strcmp(ifmt->name, last_name)>0){
3423 long_name= ifmt->long_name;
3426 if(name && strcmp(ifmt->name, name)==0)
3438 long_name ? long_name:" ");
3442 printf("Image formats (filename extensions, if any, follow):\n");
3443 for(image_fmt = first_image_format; image_fmt != NULL;
3444 image_fmt = image_fmt->next) {
3447 image_fmt->img_read ? "D":" ",
3448 image_fmt->img_write ? "E":" ",
3450 image_fmt->extensions ? image_fmt->extensions:" ");
3454 printf("Codecs:\n");
3460 const char *type_str;
3463 for(p = first_avcodec; p != NULL; p = p->next) {
3464 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3465 strcmp(p->name, last_name)>0){
3467 decode= encode= cap=0;
3469 if(p2 && strcmp(p->name, p2->name)==0){
3470 if(p->decode) decode=1;
3471 if(p->encode) encode=1;
3472 cap |= p->capabilities;
3477 last_name= p2->name;
3480 case CODEC_TYPE_VIDEO:
3483 case CODEC_TYPE_AUDIO:
3486 case CODEC_TYPE_SUBTITLE:
3495 decode ? "D": (/*p2->decoder ? "d":*/" "),
3498 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3499 cap & CODEC_CAP_DR1 ? "D":" ",
3500 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3502 /* if(p2->decoder && decode==0)
3503 printf(" use %s for decoding", p2->decoder->name);*/
3508 printf("Supported file protocols:\n");
3509 for(up = first_protocol; up != NULL; up = up->next)
3510 printf(" %s:", up->name);
3513 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3514 printf("Motion estimation methods:\n");
3518 if ((pp - motion_str + 1) == ME_ZERO)
3519 printf("(fastest)");
3520 else if ((pp - motion_str + 1) == ME_FULL)
3521 printf("(slowest)");
3522 else if ((pp - motion_str + 1) == ME_EPZS)
3523 printf("(default)");
3528 "Note, the names of encoders and decoders dont always match, so there are\n"
3529 "several cases where the above table shows encoder only or decoder only entries\n"
3530 "even though both encoding and decoding are supported for example, the h263\n"
3531 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3536 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3539 const char *p = str;
3546 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3553 static void opt_inter_matrix(const char *arg)
3555 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3556 parse_matrix_coeffs(inter_matrix, arg);
3559 static void opt_intra_matrix(const char *arg)
3561 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3562 parse_matrix_coeffs(intra_matrix, arg);
3565 static void opt_target(const char *arg)
3568 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3570 if(!strncmp(arg, "pal-", 4)) {
3573 } else if(!strncmp(arg, "ntsc-", 5)) {
3576 } else if(!strncmp(arg, "film-", 5)) {
3581 /* Calculate FR via float to avoid int overflow */
3582 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3585 } else if((fr == 29970) || (fr == 23976)) {
3588 /* Try to determine PAL/NTSC by peeking in the input files */
3589 if(nb_input_files) {
3591 for(j = 0; j < nb_input_files; j++) {
3592 for(i = 0; i < input_files[j]->nb_streams; i++) {
3593 AVCodecContext *c = input_files[j]->streams[i]->codec;
3594 if(c->codec_type != CODEC_TYPE_VIDEO)
3596 fr = c->time_base.den * 1000 / c->time_base.num;
3600 } else if((fr == 29970) || (fr == 23976)) {
3610 if(verbose && norm >= 0)
3611 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3615 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3616 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3617 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3621 if(!strcmp(arg, "vcd")) {
3623 opt_video_codec("mpeg1video");
3624 opt_audio_codec("mp2");
3627 opt_frame_size(norm ? "352x240" : "352x288");
3628 opt_frame_rate(frame_rates[norm]);
3629 opt_default("gop", norm ? "18" : "15");
3631 opt_default("b", "1150000");
3632 opt_default("maxrate", "1150000");
3633 opt_default("minrate", "1150000");
3634 opt_default("bufsize", "327680"); // 40*1024*8;
3636 audio_bit_rate = 224000;
3637 audio_sample_rate = 44100;
3639 opt_default("packetsize", "2324");
3640 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3642 /* We have to offset the PTS, so that it is consistent with the SCR.
3643 SCR starts at 36000, but the first two packs contain only padding
3644 and the first pack from the other stream, respectively, may also have
3645 been written before.
3646 So the real data starts at SCR 36000+3*1200. */
3647 mux_preload= (36000+3*1200) / 90000.0; //0.44
3648 } else if(!strcmp(arg, "svcd")) {
3650 opt_video_codec("mpeg2video");
3651 opt_audio_codec("mp2");
3654 opt_frame_size(norm ? "480x480" : "480x576");
3655 opt_frame_rate(frame_rates[norm]);
3656 opt_default("gop", norm ? "18" : "15");
3658 opt_default("b", "2040000");
3659 opt_default("maxrate", "2516000");
3660 opt_default("minrate", "0"); //1145000;
3661 opt_default("bufsize", "1835008"); //224*1024*8;
3662 opt_default("flags", "+SCAN_OFFSET");
3665 audio_bit_rate = 224000;
3666 audio_sample_rate = 44100;
3668 opt_default("packetsize", "2324");
3670 } else if(!strcmp(arg, "dvd")) {
3672 opt_video_codec("mpeg2video");
3673 opt_audio_codec("ac3");
3676 opt_frame_size(norm ? "720x480" : "720x576");
3677 opt_frame_rate(frame_rates[norm]);
3678 opt_default("gop", norm ? "18" : "15");
3680 opt_default("b", "6000000");
3681 opt_default("maxrate", "9000000");
3682 opt_default("minrate", "0"); //1500000;
3683 opt_default("bufsize", "1835008"); //224*1024*8;
3685 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3686 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3688 audio_bit_rate = 448000;
3689 audio_sample_rate = 48000;
3691 } else if(!strncmp(arg, "dv", 2)) {
3695 opt_frame_size(norm ? "720x480" : "720x576");
3696 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3697 (norm ? "yuv411p" : "yuv420p"));
3698 opt_frame_rate(frame_rates[norm]);
3700 audio_sample_rate = 48000;
3704 fprintf(stderr, "Unknown target: %s\n", arg);
3709 static void opt_video_bsf(const char *arg)
3711 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3712 AVBitStreamFilterContext **bsfp;
3715 fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3719 bsfp= &video_bitstream_filters;
3721 bsfp= &(*bsfp)->next;
3726 //FIXME avoid audio - video code duplication
3727 static void opt_audio_bsf(const char *arg)
3729 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='