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"
31 #include <sys/ioctl.h>
34 #include <sys/resource.h>
38 #include <sys/types.h>
39 #include <sys/select.h>
42 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
51 #if !defined(INFINITY) && defined(HUGE_VAL)
52 #define INFINITY HUGE_VAL
55 /* select an input stream for an output stream */
56 typedef struct AVStreamMap {
60 int sync_stream_index;
63 /** select an input file for an output file */
64 typedef struct AVMetaDataMap {
69 extern const OptionDef options[];
71 static void show_help(void);
72 static void show_license(void);
73 static int opt_default(const char *opt, const char *arg);
77 static AVFormatContext *input_files[MAX_FILES];
78 static int64_t input_files_ts_offset[MAX_FILES];
79 static int nb_input_files = 0;
81 static AVFormatContext *output_files[MAX_FILES];
82 static int nb_output_files = 0;
84 static AVStreamMap stream_maps[MAX_FILES];
85 static int nb_stream_maps;
87 static AVMetaDataMap meta_data_maps[MAX_FILES];
88 static int nb_meta_data_maps;
90 static AVInputFormat *file_iformat;
91 static AVOutputFormat *file_oformat;
92 static AVImageFormat *image_format;
93 static int frame_width = 0;
94 static int frame_height = 0;
95 static float frame_aspect_ratio = 0;
96 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
97 static int frame_padtop = 0;
98 static int frame_padbottom = 0;
99 static int frame_padleft = 0;
100 static int frame_padright = 0;
101 static int padcolor[3] = {16,128,128}; /* default to black */
102 static int frame_topBand = 0;
103 static int frame_bottomBand = 0;
104 static int frame_leftBand = 0;
105 static int frame_rightBand = 0;
106 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
107 static int frame_rate = 25;
108 static int frame_rate_base = 1;
109 static float video_qscale = 0;
110 static int video_lmin = 2*FF_QP2LAMBDA;
111 static int video_lmax = 31*FF_QP2LAMBDA;
112 static int video_mb_lmin = 2*FF_QP2LAMBDA;
113 static int video_mb_lmax = 31*FF_QP2LAMBDA;
114 static int video_qdiff = 3;
115 static uint16_t *intra_matrix = NULL;
116 static uint16_t *inter_matrix = NULL;
117 #if 0 //experimental, (can be removed)
118 static float video_rc_qsquish=1.0;
119 static float video_rc_qmod_amp=0;
120 static int video_rc_qmod_freq=0;
122 static char *video_rc_override_string=NULL;
123 static char *video_rc_eq="tex^qComp";
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 me_threshold = 0;
136 static int intra_dc_precision = 8;
137 static int me_penalty_compensation= 256;
138 static int frame_skip_factor= 0;
139 static int frame_skip_exp= 0;
140 static int loop_input = 0;
141 static int loop_output = AVFMT_NOOUTPUTLOOP;
142 static int qp_hist = 0;
144 static int intra_only = 0;
145 static int audio_sample_rate = 44100;
146 static int audio_bit_rate = 64000;
147 #define QSCALE_NONE -99999
148 static float audio_qscale = QSCALE_NONE;
149 static int audio_disable = 0;
150 static int audio_channels = 1;
151 static int audio_codec_id = CODEC_ID_NONE;
152 static int audio_codec_tag = 0;
153 static char *audio_language = NULL;
155 static int subtitle_codec_id = CODEC_ID_NONE;
156 static char *subtitle_language = NULL;
158 static float mux_preload= 0.5;
159 static float mux_max_delay= 0.7;
161 static int64_t recording_time = 0;
162 static int64_t start_time = 0;
163 static int64_t rec_timestamp = 0;
164 static int64_t input_ts_offset = 0;
165 static int file_overwrite = 0;
166 static char *str_title = NULL;
167 static char *str_author = NULL;
168 static char *str_copyright = NULL;
169 static char *str_comment = NULL;
170 static char *str_album = NULL;
171 static int do_benchmark = 0;
172 static int do_hex_dump = 0;
173 static int do_pkt_dump = 0;
174 static int do_psnr = 0;
175 static int do_vstats = 0;
176 static int do_pass = 0;
177 static char *pass_logfilename = NULL;
178 static int audio_stream_copy = 0;
179 static int video_stream_copy = 0;
180 static int subtitle_stream_copy = 0;
181 static int video_sync_method= 1;
182 static int audio_sync_method= 0;
183 static int copy_ts= 0;
184 static int opt_shortest = 0; //
185 static int video_global_header = 0;
187 static int rate_emu = 0;
190 static const char *video_grab_format = "bktr";
192 #ifdef CONFIG_VIDEO4LINUX2
193 static const char *video_grab_format = "video4linux2";
195 static const char *video_grab_format = "video4linux";
198 static char *video_device = NULL;
199 static char *grab_device = NULL;
200 static int video_channel = 0;
201 static char *video_standard = "ntsc";
203 static const char *audio_grab_format = "audio_device";
204 static char *audio_device = NULL;
205 static int audio_volume = 256;
207 static int using_stdin = 0;
208 static int using_vhook = 0;
209 static int verbose = 1;
210 static int thread_count= 1;
211 static int q_pressed = 0;
212 static int64_t video_size = 0;
213 static int64_t audio_size = 0;
214 static int64_t extra_size = 0;
215 static int nb_frames_dup = 0;
216 static int nb_frames_drop = 0;
217 static int input_sync;
218 static int limit_filesize = 0; //
220 static int pgmyuv_compatibility_hack=0;
221 static int dts_delta_threshold = 10;
223 static int sws_flags = SWS_BICUBIC;
225 const char **opt_names=NULL;
226 int opt_name_count=0;
227 AVCodecContext *avctx_opts;
228 AVFormatContext *avformat_opts;
230 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
231 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
232 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
234 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
236 struct AVInputStream;
238 typedef struct AVOutputStream {
239 int file_index; /* file index */
240 int index; /* stream index in the output file */
241 int source_index; /* AVInputStream index */
242 AVStream *st; /* stream in the output file */
243 int encoding_needed; /* true if encoding needed for this stream */
245 /* input pts and corresponding output pts
247 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
248 struct AVInputStream *sync_ist; /* input stream to sync against */
249 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
252 AVFrame pict_tmp; /* temporary image for resampling */
253 struct SwsContext *img_resample_ctx; /* for image resampling */
257 int topBand; /* cropping area sizes */
261 int padtop; /* padding area sizes */
268 ReSampleContext *resample; /* for audio resampling */
269 AVFifoBuffer fifo; /* for compression: one audio fifo per codec */
273 typedef struct AVInputStream {
277 int discard; /* true if stream data should be discarded */
278 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
279 int64_t sample_index; /* current sample */
281 int64_t start; /* time when read started */
282 unsigned long frame; /* current frame */
283 int64_t next_pts; /* synthetic pts for cases where pkt.pts
285 int64_t pts; /* current pts */
286 int is_start; /* is 1 at the start and after a discontinuity */
289 typedef struct AVInputFile {
290 int eof_reached; /* true if eof reached */
291 int ist_index; /* index of first stream in ist_table */
292 int buffer_size; /* current total buffer size */
293 int buffer_size_max; /* buffer size at which we consider we can stop
295 int nb_streams; /* nb streams we are aware of */
300 /* init terminal so that we can grab keys */
301 static struct termios oldtty;
303 static void term_exit(void)
305 tcsetattr (0, TCSANOW, &oldtty);
308 static volatile sig_atomic_t received_sigterm = 0;
311 sigterm_handler(int sig)
313 received_sigterm = sig;
317 static void term_init(void)
324 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
325 |INLCR|IGNCR|ICRNL|IXON);
326 tty.c_oflag |= OPOST;
327 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
328 tty.c_cflag &= ~(CSIZE|PARENB);
333 tcsetattr (0, TCSANOW, &tty);
335 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
336 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
337 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
339 register a function to be called at normal program termination
342 #ifdef CONFIG_BEOS_NETSERVER
343 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
347 /* read a key without blocking */
348 static int read_key(void)
352 #ifndef CONFIG_BEOS_NETSERVER
360 n = select(1, &rfds, NULL, NULL, &tv);
372 static int decode_interrupt_cb(void)
374 return q_pressed || (q_pressed = read_key() == 'q');
379 static volatile int received_sigterm = 0;
381 /* no interactive support */
382 static void term_exit(void)
386 static void term_init(void)
390 static int read_key(void)
397 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
402 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
405 /* copy stream format */
406 s->nb_streams = ic->nb_streams;
407 for(i=0;i<ic->nb_streams;i++) {
410 // FIXME: a more elegant solution is needed
411 st = av_mallocz(sizeof(AVStream));
412 memcpy(st, ic->streams[i], sizeof(AVStream));
413 st->codec = avcodec_alloc_context();
414 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
418 av_close_input_file(ic);
423 get_sync_ipts(const AVOutputStream *ost)
425 const AVInputStream *ist = ost->sync_ist;
426 return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
429 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
431 AVPacket new_pkt= *pkt;
432 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
433 &new_pkt.data, &new_pkt.size,
434 pkt->data, pkt->size,
435 pkt->flags & PKT_FLAG_KEY);
438 new_pkt.destruct= av_destruct_packet;
445 av_interleaved_write_frame(s, pkt);
448 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
450 static void do_audio_out(AVFormatContext *s,
453 unsigned char *buf, int size)
456 static uint8_t *audio_buf = NULL;
457 static uint8_t *audio_out = NULL;
458 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
460 int size_out, frame_bytes, ret;
461 AVCodecContext *enc= ost->st->codec;
463 /* SC: dynamic allocation of buffers */
465 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
467 audio_out = av_malloc(audio_out_size);
468 if (!audio_buf || !audio_out)
469 return; /* Should signal an error ! */
471 if(audio_sync_method){
472 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
473 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
474 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
475 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
477 //FIXME resample delay
478 if(fabs(delta) > 50){
481 byte_delta= FFMAX(byte_delta, -size);
485 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
490 static uint8_t *input_tmp= NULL;
491 input_tmp= av_realloc(input_tmp, byte_delta + size);
493 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
496 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
498 memset(input_tmp, 0, byte_delta);
499 memcpy(input_tmp + byte_delta, buf, size);
503 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
505 }else if(audio_sync_method>1){
506 int comp= clip(delta, -audio_sync_method, audio_sync_method);
507 assert(ost->audio_resample);
509 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
510 // 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), av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2));
511 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
515 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
516 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
518 if (ost->audio_resample) {
520 size_out = audio_resample(ost->resample,
521 (short *)buftmp, (short *)buf,
522 size / (ist->st->codec->channels * 2));
523 size_out = size_out * enc->channels * 2;
529 /* now encode as many frames as possible */
530 if (enc->frame_size > 1) {
531 /* output resampled raw samples */
532 av_fifo_write(&ost->fifo, buftmp, size_out);
534 frame_bytes = enc->frame_size * 2 * enc->channels;
536 while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
538 av_init_packet(&pkt);
540 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
543 pkt.stream_index= ost->index;
546 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
547 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
548 pkt.flags |= PKT_FLAG_KEY;
549 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
551 ost->sync_opts += enc->frame_size;
555 av_init_packet(&pkt);
557 ost->sync_opts += size_out / (2 * enc->channels);
559 /* output a pcm frame */
560 /* XXX: change encoding codec API to avoid this ? */
561 switch(enc->codec->id) {
562 case CODEC_ID_PCM_S32LE:
563 case CODEC_ID_PCM_S32BE:
564 case CODEC_ID_PCM_U32LE:
565 case CODEC_ID_PCM_U32BE:
566 size_out = size_out << 1;
568 case CODEC_ID_PCM_S24LE:
569 case CODEC_ID_PCM_S24BE:
570 case CODEC_ID_PCM_U24LE:
571 case CODEC_ID_PCM_U24BE:
572 case CODEC_ID_PCM_S24DAUD:
573 size_out = size_out / 2 * 3;
575 case CODEC_ID_PCM_S16LE:
576 case CODEC_ID_PCM_S16BE:
577 case CODEC_ID_PCM_U16LE:
578 case CODEC_ID_PCM_U16BE:
581 size_out = size_out >> 1;
584 ret = avcodec_encode_audio(enc, audio_out, size_out,
587 pkt.stream_index= ost->index;
590 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
591 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
592 pkt.flags |= PKT_FLAG_KEY;
593 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
597 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
601 AVPicture picture_tmp;
604 dec = ist->st->codec;
606 /* deinterlace : must be done before any resize */
607 if (do_deinterlace || using_vhook) {
610 /* create temporary picture */
611 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
612 buf = av_malloc(size);
616 picture2 = &picture_tmp;
617 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
620 if(avpicture_deinterlace(picture2, picture,
621 dec->pix_fmt, dec->width, dec->height) < 0) {
622 /* if error, do not deinterlace */
628 img_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
634 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
636 if (picture != picture2)
637 *picture = *picture2;
641 /* we begin to correct av delay at this threshold */
642 #define AV_DELAY_MAX 0.100
644 static void do_subtitle_out(AVFormatContext *s,
650 static uint8_t *subtitle_out = NULL;
651 int subtitle_out_max_size = 65536;
652 int subtitle_out_size, nb, i;
656 if (pts == AV_NOPTS_VALUE) {
657 fprintf(stderr, "Subtitle packets must have a pts\n");
661 enc = ost->st->codec;
664 subtitle_out = av_malloc(subtitle_out_max_size);
667 /* Note: DVB subtitle need one packet to draw them and one other
668 packet to clear them */
669 /* XXX: signal it in the codec context ? */
670 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
675 for(i = 0; i < nb; i++) {
676 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
677 subtitle_out_max_size, sub);
679 av_init_packet(&pkt);
680 pkt.stream_index = ost->index;
681 pkt.data = subtitle_out;
682 pkt.size = subtitle_out_size;
683 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);
684 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
685 /* XXX: the pts correction is handled here. Maybe handling
686 it in the codec would be better */
688 pkt.pts += 90 * sub->start_display_time;
690 pkt.pts += 90 * sub->end_display_time;
692 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
696 static int bit_buffer_size= 1024*256;
697 static uint8_t *bit_buffer= NULL;
699 static void do_video_out(AVFormatContext *s,
705 int nb_frames, i, ret;
706 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
707 AVFrame picture_crop_temp, picture_pad_temp;
708 uint8_t *buf = NULL, *buf1 = NULL;
709 AVCodecContext *enc, *dec;
711 avcodec_get_frame_defaults(&picture_crop_temp);
712 avcodec_get_frame_defaults(&picture_pad_temp);
714 enc = ost->st->codec;
715 dec = ist->st->codec;
717 /* by default, we output a single frame */
722 if(video_sync_method){
724 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
725 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
728 else if (vdelta > 1.1)
729 nb_frames = lrintf(vdelta);
730 //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);
734 fprintf(stderr, "*** drop!\n");
735 }else if (nb_frames > 1) {
736 nb_frames_dup += nb_frames;
738 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
741 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
743 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
747 if (ost->video_crop) {
748 if (img_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
749 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
752 formatted_picture = &picture_crop_temp;
754 formatted_picture = in_picture;
757 final_picture = formatted_picture;
758 padding_src = formatted_picture;
759 resampling_dst = &ost->pict_tmp;
760 if (ost->video_pad) {
761 final_picture = &ost->pict_tmp;
762 if (ost->video_resample) {
763 if (img_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
764 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
767 resampling_dst = &picture_pad_temp;
771 if (ost->video_resample) {
773 final_picture = &ost->pict_tmp;
774 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
775 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
778 if (ost->video_pad) {
779 img_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
780 enc->height, enc->width, enc->pix_fmt,
781 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
784 /* duplicates frame if needed */
785 for(i=0;i<nb_frames;i++) {
787 av_init_packet(&pkt);
788 pkt.stream_index= ost->index;
790 if (s->oformat->flags & AVFMT_RAWPICTURE) {
791 /* raw pictures are written as AVPicture structure to
792 avoid any copies. We support temorarily the older
794 AVFrame* old_frame = enc->coded_frame;
795 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
796 pkt.data= (uint8_t *)final_picture;
797 pkt.size= sizeof(AVPicture);
798 if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
799 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
800 if(dec->coded_frame && dec->coded_frame->key_frame)
801 pkt.flags |= PKT_FLAG_KEY;
803 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
804 enc->coded_frame = old_frame;
808 big_picture= *final_picture;
809 /* better than nothing: use input picture interlaced
811 big_picture.interlaced_frame = in_picture->interlaced_frame;
812 if(avctx_opts->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
813 if(top_field_first == -1)
814 big_picture.top_field_first = in_picture->top_field_first;
816 big_picture.top_field_first = top_field_first;
819 /* handles sameq here. This is not correct because it may
820 not be a global option */
822 big_picture.quality = ist->st->quality;
824 big_picture.quality = ost->st->quality;
826 big_picture.pict_type = 0;
827 // big_picture.pts = AV_NOPTS_VALUE;
828 big_picture.pts= ost->sync_opts;
829 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
830 //av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
831 ret = avcodec_encode_video(enc,
832 bit_buffer, bit_buffer_size,
834 //enc->frame_number = enc->real_pict_num;
836 pkt.data= bit_buffer;
838 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
839 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
840 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n",
841 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
842 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
844 if(enc->coded_frame && enc->coded_frame->key_frame)
845 pkt.flags |= PKT_FLAG_KEY;
846 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
848 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
849 // enc->frame_number-1, enc->real_pict_num, ret,
851 /* if two pass, output log */
852 if (ost->logfile && enc->stats_out) {
853 fprintf(ost->logfile, "%s", enc->stats_out);
865 static double psnr(double d){
866 if(d==0) return INFINITY;
867 return -10.0*log(d)/log(10.0);
870 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
873 static FILE *fvstats=NULL;
880 double ti1, bitrate, avg_bitrate;
884 today = localtime(&today2);
885 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
888 fvstats = fopen(filename,"w");
896 enc = ost->st->codec;
897 if (enc->codec_type == CODEC_TYPE_VIDEO) {
898 frame_number = ost->frame_number;
899 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
900 if (enc->flags&CODEC_FLAG_PSNR)
901 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
903 fprintf(fvstats,"f_size= %6d ", frame_size);
904 /* compute pts value */
905 ti1 = ost->sync_opts * av_q2d(enc->time_base);
909 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
910 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
911 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
912 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
913 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
917 static void print_report(AVFormatContext **output_files,
918 AVOutputStream **ost_table, int nb_ostreams,
923 AVFormatContext *oc, *os;
926 int frame_number, vid, i;
927 double bitrate, ti1, pts;
928 static int64_t last_time = -1;
929 static int qp_histogram[52];
931 if (!is_last_report) {
933 /* display the report every 0.5 seconds */
934 cur_time = av_gettime();
935 if (last_time == -1) {
936 last_time = cur_time;
939 if ((cur_time - last_time) < 500000)
941 last_time = cur_time;
945 oc = output_files[0];
947 total_size = url_ftell(&oc->pb);
952 for(i=0;i<nb_ostreams;i++) {
954 os = output_files[ost->file_index];
955 enc = ost->st->codec;
956 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
957 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
958 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
960 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
961 frame_number = ost->frame_number;
962 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%3.1f ",
963 frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
965 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
966 if(qp_hist && enc->coded_frame){
968 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
969 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
972 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
974 if (enc->flags&CODEC_FLAG_PSNR){
976 double error, error_sum=0;
977 double scale, scale_sum=0;
978 char type[3]= {'Y','U','V'};
979 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
982 error= enc->error[j];
983 scale= enc->width*enc->height*255.0*255.0*frame_number;
985 error= enc->coded_frame->error[j];
986 scale= enc->width*enc->height*255.0*255.0;
991 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
993 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
997 /* compute min output value */
998 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
999 if ((pts < ti1) && (pts > 0))
1005 if (verbose || is_last_report) {
1006 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1008 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1009 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1010 (double)total_size / 1024, ti1, bitrate);
1013 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1014 nb_frames_dup, nb_frames_drop);
1017 fprintf(stderr, "%s \r", buf);
1022 if (is_last_report && verbose >= 0){
1023 int64_t raw= audio_size + video_size + extra_size;
1024 fprintf(stderr, "\n");
1025 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1029 100.0*(total_size - raw)/raw
1034 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1035 static int output_packet(AVInputStream *ist, int ist_index,
1036 AVOutputStream **ost_table, int nb_ostreams,
1037 const AVPacket *pkt)
1039 AVFormatContext *os;
1040 AVOutputStream *ost;
1044 int data_size, got_picture;
1046 void *buffer_to_free;
1047 static unsigned int samples_size= 0;
1048 static short *samples= NULL;
1049 AVSubtitle subtitle, *subtitle_to_free;
1053 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1054 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1055 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1057 // assert(ist->pts == ist->next_pts);
1071 /* decode the packet if needed */
1072 data_buf = NULL; /* fail safe */
1074 subtitle_to_free = NULL;
1075 if (ist->decoding_needed) {
1076 switch(ist->st->codec->codec_type) {
1077 case CODEC_TYPE_AUDIO:{
1079 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1080 /* XXX: could avoid copy if PCM 16 bits with same
1081 endianness as CPU */
1082 ret = avcodec_decode_audio(ist->st->codec, samples, &data_size,
1088 /* Some bug in mpeg audio decoder gives */
1089 /* data_size < 0, it seems they are overflows */
1090 if (data_size <= 0) {
1091 /* no audio frame */
1094 data_buf = (uint8_t *)samples;
1095 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1096 (ist->st->codec->sample_rate * ist->st->codec->channels);
1098 case CODEC_TYPE_VIDEO:
1099 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1100 /* XXX: allocate picture correctly */
1101 avcodec_get_frame_defaults(&picture);
1103 ret = avcodec_decode_video(ist->st->codec,
1104 &picture, &got_picture, ptr, len);
1105 ist->st->quality= picture.quality;
1109 /* no picture yet */
1110 goto discard_packet;
1112 if (ist->st->codec->time_base.num != 0) {
1113 ist->next_pts += ((int64_t)AV_TIME_BASE *
1114 ist->st->codec->time_base.num) /
1115 ist->st->codec->time_base.den;
1119 case CODEC_TYPE_SUBTITLE:
1120 ret = avcodec_decode_subtitle(ist->st->codec,
1121 &subtitle, &got_subtitle, ptr, len);
1124 if (!got_subtitle) {
1125 goto discard_packet;
1127 subtitle_to_free = &subtitle;
1134 switch(ist->st->codec->codec_type) {
1135 case CODEC_TYPE_AUDIO:
1136 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1137 (ist->st->codec->sample_rate * ist->st->codec->channels);
1139 case CODEC_TYPE_VIDEO:
1140 if (ist->st->codec->time_base.num != 0) {
1141 ist->next_pts += ((int64_t)AV_TIME_BASE *
1142 ist->st->codec->time_base.num) /
1143 ist->st->codec->time_base.den;
1153 buffer_to_free = NULL;
1154 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1155 pre_process_video_frame(ist, (AVPicture *)&picture,
1159 // preprocess audio (volume)
1160 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1161 if (audio_volume != 256) {
1164 for(i=0;i<(data_size / sizeof(short));i++) {
1165 int v = ((*volp) * audio_volume + 128) >> 8;
1166 if (v < -32768) v = -32768;
1167 if (v > 32767) v = 32767;
1173 /* frame rate emulation */
1174 if (ist->st->codec->rate_emu) {
1175 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1176 int64_t now = av_gettime() - ist->start;
1184 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1185 is the one of the next displayed one */
1186 /* XXX: add mpeg4 too ? */
1187 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1188 if (ist->st->codec->pict_type != B_TYPE) {
1190 tmp = ist->last_ip_pts;
1191 ist->last_ip_pts = ist->frac_pts.val;
1192 ist->frac_pts.val = tmp;
1196 /* if output time reached then transcode raw format,
1197 encode packets and output them */
1198 if (start_time == 0 || ist->pts >= start_time)
1199 for(i=0;i<nb_ostreams;i++) {
1203 if (ost->source_index == ist_index) {
1204 os = output_files[ost->file_index];
1207 printf("%d: got pts=%0.3f %0.3f\n", i,
1208 (double)pkt->pts / AV_TIME_BASE,
1209 ((double)ist->pts / AV_TIME_BASE) -
1210 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1212 /* set the input output pts pairs */
1213 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1215 if (ost->encoding_needed) {
1216 switch(ost->st->codec->codec_type) {
1217 case CODEC_TYPE_AUDIO:
1218 do_audio_out(os, ost, ist, data_buf, data_size);
1220 case CODEC_TYPE_VIDEO:
1221 do_video_out(os, ost, ist, &picture, &frame_size);
1222 video_size += frame_size;
1223 if (do_vstats && frame_size)
1224 do_video_stats(os, ost, frame_size);
1226 case CODEC_TYPE_SUBTITLE:
1227 do_subtitle_out(os, ost, ist, &subtitle,
1234 AVFrame avframe; //FIXME/XXX remove this
1236 av_init_packet(&opkt);
1238 /* no reencoding needed : output the packet directly */
1239 /* force the input stream PTS */
1241 avcodec_get_frame_defaults(&avframe);
1242 ost->st->codec->coded_frame= &avframe;
1243 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1245 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1246 audio_size += data_size;
1247 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1248 video_size += data_size;
1252 opkt.stream_index= ost->index;
1253 if(pkt->pts != AV_NOPTS_VALUE)
1254 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);
1256 opkt.pts= AV_NOPTS_VALUE;
1260 if (pkt->dts == AV_NOPTS_VALUE)
1261 dts = ist->next_pts;
1263 dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1264 opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
1266 opkt.flags= pkt->flags;
1268 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1269 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1270 opkt.destruct= av_destruct_packet;
1272 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1273 ost->st->codec->frame_number++;
1274 ost->frame_number++;
1275 av_free_packet(&opkt);
1279 av_free(buffer_to_free);
1280 /* XXX: allocate the subtitles in the codec ? */
1281 if (subtitle_to_free) {
1282 if (subtitle_to_free->rects != NULL) {
1283 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1284 av_free(subtitle_to_free->rects[i].bitmap);
1285 av_free(subtitle_to_free->rects[i].rgba_palette);
1287 av_freep(&subtitle_to_free->rects);
1289 subtitle_to_free->num_rects = 0;
1290 subtitle_to_free = NULL;
1297 for(i=0;i<nb_ostreams;i++) {
1299 if (ost->source_index == ist_index) {
1300 AVCodecContext *enc= ost->st->codec;
1301 os = output_files[ost->file_index];
1303 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1305 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1308 if (ost->encoding_needed) {
1312 av_init_packet(&pkt);
1313 pkt.stream_index= ost->index;
1315 switch(ost->st->codec->codec_type) {
1316 case CODEC_TYPE_AUDIO:
1317 fifo_bytes = av_fifo_size(&ost->fifo);
1319 /* encode any samples remaining in fifo */
1320 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1321 int fs_tmp = enc->frame_size;
1322 enc->frame_size = fifo_bytes / (2 * enc->channels);
1323 if(av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes) == 0) {
1324 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1326 enc->frame_size = fs_tmp;
1329 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1332 pkt.flags |= PKT_FLAG_KEY;
1334 case CODEC_TYPE_VIDEO:
1335 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1337 if(enc->coded_frame && enc->coded_frame->key_frame)
1338 pkt.flags |= PKT_FLAG_KEY;
1339 if (ost->logfile && enc->stats_out) {
1340 fprintf(ost->logfile, "%s", enc->stats_out);
1349 pkt.data= bit_buffer;
1351 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1352 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1353 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1367 * The following code is the main loop of the file converter
1369 static int av_encode(AVFormatContext **output_files,
1370 int nb_output_files,
1371 AVFormatContext **input_files,
1373 AVStreamMap *stream_maps, int nb_stream_maps)
1375 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1376 AVFormatContext *is, *os;
1377 AVCodecContext *codec, *icodec;
1378 AVOutputStream *ost, **ost_table = NULL;
1379 AVInputStream *ist, **ist_table = NULL;
1380 AVInputFile *file_table;
1381 AVFormatContext *stream_no_data;
1384 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1388 /* input stream init */
1390 for(i=0;i<nb_input_files;i++) {
1391 is = input_files[i];
1392 file_table[i].ist_index = j;
1393 file_table[i].nb_streams = is->nb_streams;
1394 j += is->nb_streams;
1398 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1402 for(i=0;i<nb_istreams;i++) {
1403 ist = av_mallocz(sizeof(AVInputStream));
1409 for(i=0;i<nb_input_files;i++) {
1410 is = input_files[i];
1411 for(k=0;k<is->nb_streams;k++) {
1412 ist = ist_table[j++];
1413 ist->st = is->streams[k];
1414 ist->file_index = i;
1416 ist->discard = 1; /* the stream is discarded by default
1419 if (ist->st->codec->rate_emu) {
1420 ist->start = av_gettime();
1426 /* output stream init */
1428 for(i=0;i<nb_output_files;i++) {
1429 os = output_files[i];
1430 nb_ostreams += os->nb_streams;
1432 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1433 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1437 /* Sanity check the mapping args -- do the input files & streams exist? */
1438 for(i=0;i<nb_stream_maps;i++) {
1439 int fi = stream_maps[i].file_index;
1440 int si = stream_maps[i].stream_index;
1442 if (fi < 0 || fi > nb_input_files - 1 ||
1443 si < 0 || si > file_table[fi].nb_streams - 1) {
1444 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1447 fi = stream_maps[i].sync_file_index;
1448 si = stream_maps[i].sync_stream_index;
1449 if (fi < 0 || fi > nb_input_files - 1 ||
1450 si < 0 || si > file_table[fi].nb_streams - 1) {
1451 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1456 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1459 for(i=0;i<nb_ostreams;i++) {
1460 ost = av_mallocz(sizeof(AVOutputStream));
1467 for(k=0;k<nb_output_files;k++) {
1468 os = output_files[k];
1469 for(i=0;i<os->nb_streams;i++) {
1471 ost = ost_table[n++];
1472 ost->file_index = k;
1474 ost->st = os->streams[i];
1475 if (nb_stream_maps > 0) {
1476 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1477 stream_maps[n-1].stream_index;
1479 /* Sanity check that the stream types match */
1480 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1481 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1482 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1483 ost->file_index, ost->index);
1488 /* get corresponding input stream index : we select the first one with the right type */
1490 for(j=0;j<nb_istreams;j++) {
1493 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1494 ost->source_index = j;
1501 /* try again and reuse existing stream */
1502 for(j=0;j<nb_istreams;j++) {
1504 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1505 ost->source_index = j;
1510 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1511 ost->file_index, ost->index);
1516 ist = ist_table[ost->source_index];
1518 ost->sync_ist = (nb_stream_maps > 0) ?
1519 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1520 stream_maps[n-1].sync_stream_index] : ist;
1524 /* for each output stream, we compute the right encoding parameters */
1525 for(i=0;i<nb_ostreams;i++) {
1527 ist = ist_table[ost->source_index];
1529 codec = ost->st->codec;
1530 icodec = ist->st->codec;
1532 if (ost->st->stream_copy) {
1533 /* if stream_copy is selected, no need to decode or encode */
1534 codec->codec_id = icodec->codec_id;
1535 codec->codec_type = icodec->codec_type;
1536 if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1537 codec->bit_rate = icodec->bit_rate;
1538 codec->extradata= icodec->extradata;
1539 codec->extradata_size= icodec->extradata_size;
1540 codec->time_base = icodec->time_base;
1541 switch(codec->codec_type) {
1542 case CODEC_TYPE_AUDIO:
1543 codec->sample_rate = icodec->sample_rate;
1544 codec->channels = icodec->channels;
1545 codec->frame_size = icodec->frame_size;
1546 codec->block_align= icodec->block_align;
1548 case CODEC_TYPE_VIDEO:
1549 codec->pix_fmt = icodec->pix_fmt;
1550 codec->width = icodec->width;
1551 codec->height = icodec->height;
1552 codec->has_b_frames = icodec->has_b_frames;
1554 case CODEC_TYPE_SUBTITLE:
1560 switch(codec->codec_type) {
1561 case CODEC_TYPE_AUDIO:
1562 if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1565 if (codec->channels == icodec->channels &&
1566 codec->sample_rate == icodec->sample_rate) {
1567 ost->audio_resample = 0;
1569 if (codec->channels != icodec->channels &&
1570 (icodec->codec_id == CODEC_ID_AC3 ||
1571 icodec->codec_id == CODEC_ID_DTS)) {
1572 /* Special case for 5:1 AC3 and DTS input */
1573 /* and mono or stereo output */
1574 /* Request specific number of channels */
1575 icodec->channels = codec->channels;
1576 if (codec->sample_rate == icodec->sample_rate)
1577 ost->audio_resample = 0;
1579 ost->audio_resample = 1;
1582 ost->audio_resample = 1;
1585 if(audio_sync_method>1)
1586 ost->audio_resample = 1;
1588 if(ost->audio_resample){
1589 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1590 codec->sample_rate, icodec->sample_rate);
1592 printf("Can't resample. Aborting.\n");
1596 ist->decoding_needed = 1;
1597 ost->encoding_needed = 1;
1599 case CODEC_TYPE_VIDEO:
1600 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1601 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1602 ost->video_resample = ((codec->width != icodec->width -
1603 (frame_leftBand + frame_rightBand) +
1604 (frame_padleft + frame_padright)) ||
1605 (codec->height != icodec->height -
1606 (frame_topBand + frame_bottomBand) +
1607 (frame_padtop + frame_padbottom)) ||
1608 (codec->pix_fmt != icodec->pix_fmt));
1609 if (ost->video_crop) {
1610 ost->topBand = frame_topBand;
1611 ost->leftBand = frame_leftBand;
1613 if (ost->video_pad) {
1614 ost->padtop = frame_padtop;
1615 ost->padleft = frame_padleft;
1616 ost->padbottom = frame_padbottom;
1617 ost->padright = frame_padright;
1618 if (!ost->video_resample) {
1619 avcodec_get_frame_defaults(&ost->pict_tmp);
1620 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1621 codec->width, codec->height ) )
1625 if (ost->video_resample) {
1626 avcodec_get_frame_defaults(&ost->pict_tmp);
1627 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1628 codec->width, codec->height ) )
1631 ost->img_resample_ctx = sws_getContext(
1632 icodec->width - (frame_leftBand + frame_rightBand),
1633 icodec->height - (frame_topBand + frame_bottomBand),
1635 codec->width - (frame_padleft + frame_padright),
1636 codec->height - (frame_padtop + frame_padbottom),
1638 sws_flags, NULL, NULL, NULL);
1639 if (ost->img_resample_ctx == NULL) {
1640 fprintf(stderr, "Cannot get resampling context\n");
1643 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1645 ost->encoding_needed = 1;
1646 ist->decoding_needed = 1;
1648 case CODEC_TYPE_SUBTITLE:
1649 ost->encoding_needed = 1;
1650 ist->decoding_needed = 1;
1657 if (ost->encoding_needed &&
1658 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1659 char logfilename[1024];
1664 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1666 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1667 if (codec->flags & CODEC_FLAG_PASS1) {
1668 f = fopen(logfilename, "w");
1670 perror(logfilename);
1675 /* read the log file */
1676 f = fopen(logfilename, "r");
1678 perror(logfilename);
1681 fseek(f, 0, SEEK_END);
1683 fseek(f, 0, SEEK_SET);
1684 logbuffer = av_malloc(size + 1);
1686 fprintf(stderr, "Could not allocate log buffer\n");
1689 size = fread(logbuffer, 1, size, f);
1691 logbuffer[size] = '\0';
1692 codec->stats_in = logbuffer;
1696 if(codec->codec_type == CODEC_TYPE_VIDEO){
1697 int size= codec->width * codec->height;
1698 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1703 bit_buffer = av_malloc(bit_buffer_size);
1707 /* dump the file output parameters - cannot be done before in case
1709 for(i=0;i<nb_output_files;i++) {
1710 dump_format(output_files[i], i, output_files[i]->filename, 1);
1713 /* dump the stream mapping */
1715 fprintf(stderr, "Stream mapping:\n");
1716 for(i=0;i<nb_ostreams;i++) {
1718 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1719 ist_table[ost->source_index]->file_index,
1720 ist_table[ost->source_index]->index,
1723 if (ost->sync_ist != ist_table[ost->source_index])
1724 fprintf(stderr, " [sync #%d.%d]",
1725 ost->sync_ist->file_index,
1726 ost->sync_ist->index);
1727 fprintf(stderr, "\n");
1731 /* open each encoder */
1732 for(i=0;i<nb_ostreams;i++) {
1734 if (ost->encoding_needed) {
1736 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1738 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1739 ost->file_index, ost->index);
1742 if (avcodec_open(ost->st->codec, codec) < 0) {
1743 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1744 ost->file_index, ost->index);
1747 extra_size += ost->st->codec->extradata_size;
1751 /* open each decoder */
1752 for(i=0;i<nb_istreams;i++) {
1754 if (ist->decoding_needed) {
1756 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1758 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1759 ist->st->codec->codec_id, ist->file_index, ist->index);
1762 if (avcodec_open(ist->st->codec, codec) < 0) {
1763 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1764 ist->file_index, ist->index);
1767 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1768 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1773 for(i=0;i<nb_istreams;i++) {
1775 is = input_files[ist->file_index];
1777 ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1778 if(ist->st->start_time == AV_NOPTS_VALUE)
1780 if(input_files_ts_offset[ist->file_index])
1781 ist->next_pts= AV_NOPTS_VALUE;
1785 /* compute buffer size max (should use a complete heuristic) */
1786 for(i=0;i<nb_input_files;i++) {
1787 file_table[i].buffer_size_max = 2048;
1790 /* set meta data information from input file if required */
1791 for (i=0;i<nb_meta_data_maps;i++) {
1792 AVFormatContext *out_file;
1793 AVFormatContext *in_file;
1795 int out_file_index = meta_data_maps[i].out_file;
1796 int in_file_index = meta_data_maps[i].in_file;
1797 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1798 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1802 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1803 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1808 out_file = output_files[out_file_index];
1809 in_file = input_files[in_file_index];
1811 strcpy(out_file->title, in_file->title);
1812 strcpy(out_file->author, in_file->author);
1813 strcpy(out_file->copyright, in_file->copyright);
1814 strcpy(out_file->comment, in_file->comment);
1815 strcpy(out_file->album, in_file->album);
1816 out_file->year = in_file->year;
1817 out_file->track = in_file->track;
1818 strcpy(out_file->genre, in_file->genre);
1821 /* open files and write file headers */
1822 for(i=0;i<nb_output_files;i++) {
1823 os = output_files[i];
1824 if (av_write_header(os) < 0) {
1825 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1832 if ( !using_stdin && verbose >= 0) {
1833 fprintf(stderr, "Press [q] to stop encoding\n");
1834 url_set_interrupt_cb(decode_interrupt_cb);
1842 for(; received_sigterm == 0;) {
1843 int file_index, ist_index;
1851 /* if 'q' pressed, exits */
1855 /* read_key() returns 0 on EOF */
1861 /* select the stream that we must read now by looking at the
1862 smallest output pts */
1864 for(i=0;i<nb_ostreams;i++) {
1867 os = output_files[ost->file_index];
1868 ist = ist_table[ost->source_index];
1869 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1870 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1872 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1873 ipts = (double)ist->pts;
1874 if (!file_table[ist->file_index].eof_reached){
1875 if(ipts < ipts_min) {
1877 if(input_sync ) file_index = ist->file_index;
1879 if(opts < opts_min) {
1881 if(!input_sync) file_index = ist->file_index;
1884 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1889 /* if none, if is finished */
1890 if (file_index < 0) {
1894 /* finish if recording time exhausted */
1895 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1898 /* finish if limit size exhausted */
1899 if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1902 /* read a frame from it and output it in the fifo */
1903 is = input_files[file_index];
1904 if (av_read_frame(is, &pkt) < 0) {
1905 file_table[file_index].eof_reached = 1;
1906 if (opt_shortest) break; else continue; //
1910 stream_no_data = is;
1915 av_pkt_dump(stdout, &pkt, do_hex_dump);
1917 /* the following test is needed in case new streams appear
1918 dynamically in stream : we ignore them */
1919 if (pkt.stream_index >= file_table[file_index].nb_streams)
1920 goto discard_packet;
1921 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1922 ist = ist_table[ist_index];
1924 goto discard_packet;
1926 // 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);
1927 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1928 int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1929 if(ABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1930 input_files_ts_offset[ist->file_index]-= delta;
1932 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1933 for(i=0; i<file_table[file_index].nb_streams; i++){
1934 int index= file_table[file_index].ist_index + i;
1935 ist_table[index]->next_pts += delta;
1936 ist_table[index]->is_start=1;
1941 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1942 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1945 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1946 ist->file_index, ist->index);
1948 av_free_packet(&pkt);
1953 av_free_packet(&pkt);
1955 /* dump report by using the output first video and audio streams */
1956 print_report(output_files, ost_table, nb_ostreams, 0);
1959 /* at the end of stream, we must flush the decoder buffers */
1960 for(i=0;i<nb_istreams;i++) {
1962 if (ist->decoding_needed) {
1963 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1969 /* write the trailer if needed and close file */
1970 for(i=0;i<nb_output_files;i++) {
1971 os = output_files[i];
1972 av_write_trailer(os);
1975 /* dump report by using the first video and audio streams */
1976 print_report(output_files, ost_table, nb_ostreams, 1);
1978 /* close each encoder */
1979 for(i=0;i<nb_ostreams;i++) {
1981 if (ost->encoding_needed) {
1982 av_freep(&ost->st->codec->stats_in);
1983 avcodec_close(ost->st->codec);
1987 /* close each decoder */
1988 for(i=0;i<nb_istreams;i++) {
1990 if (ist->decoding_needed) {
1991 avcodec_close(ist->st->codec);
1999 av_freep(&bit_buffer);
2000 av_free(file_table);
2003 for(i=0;i<nb_istreams;i++) {
2010 for(i=0;i<nb_ostreams;i++) {
2014 fclose(ost->logfile);
2015 ost->logfile = NULL;
2017 av_fifo_free(&ost->fifo); /* works even if fifo is not
2018 initialized but set to zero */
2019 av_free(ost->pict_tmp.data[0]);
2020 if (ost->video_resample)
2021 sws_freeContext(ost->img_resample_ctx);
2022 if (ost->audio_resample)
2023 audio_resample_close(ost->resample);
2036 int file_read(const char *filename)
2039 unsigned char buffer[1024];
2042 if (url_open(&h, filename, O_RDONLY) < 0) {
2043 printf("could not open '%s'\n", filename);
2047 len = url_read(h, buffer, sizeof(buffer));
2050 for(i=0;i<len;i++) putchar(buffer[i]);
2057 static void opt_image_format(const char *arg)
2061 for(f = first_image_format; f != NULL; f = f->next) {
2062 if (!strcmp(arg, f->name))
2066 fprintf(stderr, "Unknown image format: '%s'\n", arg);
2072 static void opt_format(const char *arg)
2074 /* compatibility stuff for pgmyuv */
2075 if (!strcmp(arg, "pgmyuv")) {
2076 pgmyuv_compatibility_hack=1;
2077 // opt_image_format(arg);
2081 file_iformat = av_find_input_format(arg);
2082 file_oformat = guess_format(arg, NULL, NULL);
2083 if (!file_iformat && !file_oformat) {
2084 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2089 static void opt_video_rc_eq(char *arg)
2094 static void opt_video_rc_override_string(char *arg)
2096 video_rc_override_string = arg;
2099 static void opt_me_threshold(const char *arg)
2101 me_threshold = atoi(arg);
2104 static void opt_verbose(const char *arg)
2106 verbose = atoi(arg);
2107 av_log_set_level(atoi(arg));
2110 static void opt_frame_rate(const char *arg)
2112 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2113 fprintf(stderr, "Incorrect frame rate\n");
2118 static void opt_frame_crop_top(const char *arg)
2120 frame_topBand = atoi(arg);
2121 if (frame_topBand < 0) {
2122 fprintf(stderr, "Incorrect top crop size\n");
2125 if ((frame_topBand % 2) != 0) {
2126 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2129 if ((frame_topBand) >= frame_height){
2130 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2133 frame_height -= frame_topBand;
2136 static void opt_frame_crop_bottom(const char *arg)
2138 frame_bottomBand = atoi(arg);
2139 if (frame_bottomBand < 0) {
2140 fprintf(stderr, "Incorrect bottom crop size\n");
2143 if ((frame_bottomBand % 2) != 0) {
2144 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2147 if ((frame_bottomBand) >= frame_height){
2148 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2151 frame_height -= frame_bottomBand;
2154 static void opt_frame_crop_left(const char *arg)
2156 frame_leftBand = atoi(arg);
2157 if (frame_leftBand < 0) {
2158 fprintf(stderr, "Incorrect left crop size\n");
2161 if ((frame_leftBand % 2) != 0) {
2162 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2165 if ((frame_leftBand) >= frame_width){
2166 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2169 frame_width -= frame_leftBand;
2172 static void opt_frame_crop_right(const char *arg)
2174 frame_rightBand = atoi(arg);
2175 if (frame_rightBand < 0) {
2176 fprintf(stderr, "Incorrect right crop size\n");
2179 if ((frame_rightBand % 2) != 0) {
2180 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2183 if ((frame_rightBand) >= frame_width){
2184 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2187 frame_width -= frame_rightBand;
2190 static void opt_frame_size(const char *arg)
2192 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2193 fprintf(stderr, "Incorrect frame size\n");
2196 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2197 fprintf(stderr, "Frame size must be a multiple of 2\n");
2203 #define SCALEBITS 10
2204 #define ONE_HALF (1 << (SCALEBITS - 1))
2205 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2207 #define RGB_TO_Y(r, g, b) \
2208 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2209 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2211 #define RGB_TO_U(r1, g1, b1, shift)\
2212 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2213 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2215 #define RGB_TO_V(r1, g1, b1, shift)\
2216 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2217 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2219 static void opt_pad_color(const char *arg) {
2220 /* Input is expected to be six hex digits similar to
2221 how colors are expressed in html tags (but without the #) */
2222 int rgb = strtol(arg, NULL, 16);
2226 g = ((rgb >> 8) & 255);
2229 padcolor[0] = RGB_TO_Y(r,g,b);
2230 padcolor[1] = RGB_TO_U(r,g,b,0);
2231 padcolor[2] = RGB_TO_V(r,g,b,0);
2234 static void opt_frame_pad_top(const char *arg)
2236 frame_padtop = atoi(arg);
2237 if (frame_padtop < 0) {
2238 fprintf(stderr, "Incorrect top pad size\n");
2241 if ((frame_padtop % 2) != 0) {
2242 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2247 static void opt_frame_pad_bottom(const char *arg)
2249 frame_padbottom = atoi(arg);
2250 if (frame_padbottom < 0) {
2251 fprintf(stderr, "Incorrect bottom pad size\n");
2254 if ((frame_padbottom % 2) != 0) {
2255 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2261 static void opt_frame_pad_left(const char *arg)
2263 frame_padleft = atoi(arg);
2264 if (frame_padleft < 0) {
2265 fprintf(stderr, "Incorrect left pad size\n");
2268 if ((frame_padleft % 2) != 0) {
2269 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2275 static void opt_frame_pad_right(const char *arg)
2277 frame_padright = atoi(arg);
2278 if (frame_padright < 0) {
2279 fprintf(stderr, "Incorrect right pad size\n");
2282 if ((frame_padright % 2) != 0) {
2283 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2289 static void opt_frame_pix_fmt(const char *arg)
2291 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2294 static void opt_frame_aspect_ratio(const char *arg)
2300 p = strchr(arg, ':');
2302 x = strtol(arg, (char **)&arg, 10);
2304 y = strtol(arg+1, (char **)&arg, 10);
2306 ar = (double)x / (double)y;
2308 ar = strtod(arg, (char **)&arg);
2311 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2314 frame_aspect_ratio = ar;
2317 static void opt_qscale(const char *arg)
2319 video_qscale = atof(arg);
2320 if (video_qscale <= 0 ||
2321 video_qscale > 255) {
2322 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2327 static void opt_lmax(const char *arg)
2329 video_lmax = atof(arg)*FF_QP2LAMBDA;
2332 static void opt_lmin(const char *arg)
2334 video_lmin = atof(arg)*FF_QP2LAMBDA;
2337 static void opt_mb_lmin(const char *arg)
2339 video_mb_lmin = atof(arg)*FF_QP2LAMBDA;
2340 if (video_mb_lmin < 1 ||
2341 video_mb_lmin > FF_LAMBDA_MAX) {
2342 fprintf(stderr, "mblmin must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2347 static void opt_mb_lmax(const char *arg)
2349 video_mb_lmax = atof(arg)*FF_QP2LAMBDA;
2350 if (video_mb_lmax < 1 ||
2351 video_mb_lmax > FF_LAMBDA_MAX) {
2352 fprintf(stderr, "mblmax must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2357 static void opt_qdiff(const char *arg)
2359 video_qdiff = atoi(arg);
2360 if (video_qdiff < 0 ||
2362 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2367 static void opt_packet_size(const char *arg)
2369 packet_size= atoi(arg);
2372 static void opt_error_rate(const char *arg)
2374 error_rate= atoi(arg);
2377 static void opt_strict(const char *arg)
2382 static void opt_top_field_first(const char *arg)
2384 top_field_first= atoi(arg);
2387 static void opt_thread_count(const char *arg)
2389 thread_count= atoi(arg);
2390 #if !defined(HAVE_THREADS)
2392 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2396 static void opt_audio_bitrate(const char *arg)
2398 audio_bit_rate = atoi(arg) * 1000;
2401 static void opt_audio_rate(const char *arg)
2403 audio_sample_rate = atoi(arg);
2406 static void opt_audio_channels(const char *arg)
2408 audio_channels = atoi(arg);
2411 static void opt_video_device(const char *arg)
2413 video_device = av_strdup(arg);
2416 static void opt_grab_device(const char *arg)
2418 grab_device = av_strdup(arg);
2421 static void opt_video_channel(const char *arg)
2423 video_channel = strtol(arg, NULL, 0);
2426 static void opt_video_standard(const char *arg)
2428 video_standard = av_strdup(arg);
2431 static void opt_audio_device(const char *arg)
2433 audio_device = av_strdup(arg);
2436 static void opt_codec(int *pstream_copy, int *pcodec_id,
2437 int codec_type, const char *arg)
2441 if (!strcmp(arg, "copy")) {
2446 if (!strcmp(p->name, arg) && p->type == codec_type)
2451 fprintf(stderr, "Unknown codec '%s'\n", arg);
2459 static void opt_audio_codec(const char *arg)
2461 opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2464 static void opt_audio_tag(const char *arg)
2467 audio_codec_tag= strtol(arg, &tail, 0);
2470 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2473 static void opt_video_tag(const char *arg)
2476 video_codec_tag= strtol(arg, &tail, 0);
2479 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2482 static void add_frame_hooker(const char *arg)
2487 char *args = av_strdup(arg);
2491 argv[0] = strtok(args, " ");
2492 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2495 i = frame_hook_add(argc, argv);
2498 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2503 const char *motion_str[] = {
2516 static void opt_motion_estimation(const char *arg)
2522 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2525 if (!strcmp(*p, arg))
2529 me_method = (p - motion_str) + 1;
2532 static void opt_video_codec(const char *arg)
2534 opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2537 static void opt_subtitle_codec(const char *arg)
2539 opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2542 static void opt_map(const char *arg)
2548 m = &stream_maps[nb_stream_maps++];
2550 m->file_index = strtol(arg, (char **)&p, 0);
2554 m->stream_index = strtol(p, (char **)&p, 0);
2557 m->sync_file_index = strtol(p, (char **)&p, 0);
2560 m->sync_stream_index = strtol(p, (char **)&p, 0);
2562 m->sync_file_index = m->file_index;
2563 m->sync_stream_index = m->stream_index;
2567 static void opt_map_meta_data(const char *arg)
2573 m = &meta_data_maps[nb_meta_data_maps++];
2575 m->out_file = strtol(arg, (char **)&p, 0);
2579 m->in_file = strtol(p, (char **)&p, 0);
2582 static void opt_recording_time(const char *arg)
2584 recording_time = parse_date(arg, 1);
2587 static void opt_start_time(const char *arg)
2589 start_time = parse_date(arg, 1);
2592 static void opt_rec_timestamp(const char *arg)
2594 rec_timestamp = parse_date(arg, 0) / 1000000;
2597 static void opt_input_ts_offset(const char *arg)
2599 input_ts_offset = parse_date(arg, 1);
2602 static void opt_input_file(const char *filename)
2604 AVFormatContext *ic;
2605 AVFormatParameters params, *ap = ¶ms;
2606 int err, i, ret, rfps, rfps_base;
2609 if (!strcmp(filename, "-"))
2612 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2613 !strcmp( filename, "/dev/stdin" );
2615 /* get default parameters from command line */
2616 ic = av_alloc_format_context();
2618 memset(ap, 0, sizeof(*ap));
2619 ap->prealloced_context = 1;
2620 ap->sample_rate = audio_sample_rate;
2621 ap->channels = audio_channels;
2622 ap->time_base.den = frame_rate;
2623 ap->time_base.num = frame_rate_base;
2624 ap->width = frame_width + frame_padleft + frame_padright;
2625 ap->height = frame_height + frame_padtop + frame_padbottom;
2626 ap->image_format = image_format;
2627 ap->pix_fmt = frame_pix_fmt;
2628 ap->device = grab_device;
2629 ap->channel = video_channel;
2630 ap->standard = video_standard;
2631 ap->video_codec_id = video_codec_id;
2632 ap->audio_codec_id = audio_codec_id;
2633 if(pgmyuv_compatibility_hack)
2634 ap->video_codec_id= CODEC_ID_PGMYUV;
2636 for(i=0; i<opt_name_count; i++){
2638 double d= av_get_double(avformat_opts, opt_names[i], &opt);
2639 if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2640 av_set_double(ic, opt_names[i], d);
2642 /* open the input file with generic libav function */
2643 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2645 print_error(filename, err);
2649 ic->loop_input = loop_input;
2651 /* If not enough info to get the stream parameters, we decode the
2652 first frames to get it. (used in mpeg case for example) */
2653 ret = av_find_stream_info(ic);
2654 if (ret < 0 && verbose >= 0) {
2655 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2659 timestamp = start_time;
2660 /* add the stream start time */
2661 if (ic->start_time != AV_NOPTS_VALUE)
2662 timestamp += ic->start_time;
2664 /* if seeking requested, we execute it */
2665 if (start_time != 0) {
2666 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2668 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2669 filename, (double)timestamp / AV_TIME_BASE);
2671 /* reset seek info */
2675 /* update the current parameters so that they match the one of the input stream */
2676 for(i=0;i<ic->nb_streams;i++) {
2678 AVCodecContext *enc = ic->streams[i]->codec;
2679 #if defined(HAVE_THREADS)
2681 avcodec_thread_init(enc, thread_count);
2683 enc->thread_count= thread_count;
2684 switch(enc->codec_type) {
2685 case CODEC_TYPE_AUDIO:
2686 for(j=0; j<opt_name_count; j++){
2688 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2689 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2690 av_set_double(enc, opt_names[j], d);
2692 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2693 audio_channels = enc->channels;
2694 audio_sample_rate = enc->sample_rate;
2696 ic->streams[i]->discard= AVDISCARD_ALL;
2698 case CODEC_TYPE_VIDEO:
2699 for(j=0; j<opt_name_count; j++){
2701 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2702 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2703 av_set_double(enc, opt_names[j], d);
2705 frame_height = enc->height;
2706 frame_width = enc->width;
2707 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2708 frame_pix_fmt = enc->pix_fmt;
2709 rfps = ic->streams[i]->r_frame_rate.num;
2710 rfps_base = ic->streams[i]->r_frame_rate.den;
2711 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2713 enc->debug |= FF_DEBUG_MV;
2715 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2718 fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2719 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2721 (float)rfps / rfps_base, rfps, rfps_base);
2723 /* update the current frame rate to match the stream frame rate */
2725 frame_rate_base = rfps_base;
2727 enc->rate_emu = rate_emu;
2729 ic->streams[i]->discard= AVDISCARD_ALL;
2730 else if(video_discard)
2731 ic->streams[i]->discard= video_discard;
2733 case CODEC_TYPE_DATA:
2735 case CODEC_TYPE_SUBTITLE:
2737 case CODEC_TYPE_UNKNOWN:
2744 input_files[nb_input_files] = ic;
2745 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2746 /* dump the file content */
2748 dump_format(ic, nb_input_files, filename, 0);
2751 file_iformat = NULL;
2752 file_oformat = NULL;
2753 image_format = NULL;
2761 static void opt_grab(const char *arg)
2763 file_iformat = av_find_input_format(arg);
2767 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2769 int has_video, has_audio, i, j;
2770 AVFormatContext *ic;
2774 for(j=0;j<nb_input_files;j++) {
2775 ic = input_files[j];
2776 for(i=0;i<ic->nb_streams;i++) {
2777 AVCodecContext *enc = ic->streams[i]->codec;
2778 switch(enc->codec_type) {
2779 case CODEC_TYPE_AUDIO:
2782 case CODEC_TYPE_VIDEO:
2785 case CODEC_TYPE_DATA:
2786 case CODEC_TYPE_UNKNOWN:
2787 case CODEC_TYPE_SUBTITLE:
2794 *has_video_ptr = has_video;
2795 *has_audio_ptr = has_audio;
2798 static void new_video_stream(AVFormatContext *oc)
2801 AVCodecContext *video_enc;
2804 st = av_new_stream(oc, oc->nb_streams);
2806 fprintf(stderr, "Could not alloc stream\n");
2809 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2810 video_bitstream_filters= NULL;
2812 #if defined(HAVE_THREADS)
2814 avcodec_thread_init(st->codec, thread_count);
2817 video_enc = st->codec;
2820 video_enc->codec_tag= video_codec_tag;
2822 if( (video_global_header&1)
2823 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2824 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2825 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2827 if(video_global_header&2){
2828 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2829 avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2832 if (video_stream_copy) {
2833 st->stream_copy = 1;
2834 video_enc->codec_type = CODEC_TYPE_VIDEO;
2840 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2841 if (video_codec_id != CODEC_ID_NONE)
2842 codec_id = video_codec_id;
2844 video_enc->codec_id = codec_id;
2845 codec = avcodec_find_encoder(codec_id);
2847 for(i=0; i<opt_name_count; i++){
2849 double d= av_get_double(avctx_opts, opt_names[i], &opt);
2850 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2851 av_set_double(video_enc, opt_names[i], d);
2854 video_enc->time_base.den = frame_rate;
2855 video_enc->time_base.num = frame_rate_base;
2856 if(codec && codec->supported_framerates){
2857 const AVRational *p= codec->supported_framerates;
2858 AVRational req= (AVRational){frame_rate, frame_rate_base};
2859 const AVRational *best=NULL;
2860 AVRational best_error= (AVRational){INT_MAX, 1};
2861 for(; p->den!=0; p++){
2862 AVRational error= av_sub_q(req, *p);
2863 if(error.num <0) error.num *= -1;
2864 if(av_cmp_q(error, best_error) < 0){
2869 video_enc->time_base.den= best->num;
2870 video_enc->time_base.num= best->den;
2873 video_enc->width = frame_width + frame_padright + frame_padleft;
2874 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2875 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2876 video_enc->pix_fmt = frame_pix_fmt;
2878 if(codec && codec->pix_fmts){
2879 const enum PixelFormat *p= codec->pix_fmts;
2881 if(*p == video_enc->pix_fmt)
2885 video_enc->pix_fmt = codec->pix_fmts[0];
2889 video_enc->gop_size = 0;
2890 if (video_qscale || same_quality) {
2891 video_enc->flags |= CODEC_FLAG_QSCALE;
2892 video_enc->global_quality=
2893 st->quality = FF_QP2LAMBDA * video_qscale;
2897 video_enc->intra_matrix = intra_matrix;
2899 video_enc->inter_matrix = inter_matrix;
2901 video_enc->lmin = video_lmin;
2902 video_enc->lmax = video_lmax;
2903 video_enc->mb_lmin = video_mb_lmin;
2904 video_enc->mb_lmax = video_mb_lmax;
2905 video_enc->max_qdiff = video_qdiff;
2906 video_enc->rc_eq = video_rc_eq;
2907 video_enc->thread_count = thread_count;
2908 p= video_rc_override_string;
2911 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2913 fprintf(stderr, "error parsing rc_override\n");
2916 video_enc->rc_override=
2917 av_realloc(video_enc->rc_override,
2918 sizeof(RcOverride)*(i+1));
2919 video_enc->rc_override[i].start_frame= start;
2920 video_enc->rc_override[i].end_frame = end;
2922 video_enc->rc_override[i].qscale= q;
2923 video_enc->rc_override[i].quality_factor= 1.0;
2926 video_enc->rc_override[i].qscale= 0;
2927 video_enc->rc_override[i].quality_factor= -q/100.0;
2932 video_enc->rc_override_count=i;
2933 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2934 video_enc->me_threshold= me_threshold;
2935 video_enc->intra_dc_precision= intra_dc_precision - 8;
2936 video_enc->strict_std_compliance = strict;
2937 video_enc->error_rate = error_rate;
2938 video_enc->me_penalty_compensation= me_penalty_compensation;
2939 video_enc->frame_skip_factor= frame_skip_factor;
2940 video_enc->frame_skip_exp= frame_skip_exp;
2943 video_enc->rtp_mode= 1;
2944 video_enc->rtp_payload_size= packet_size;
2948 video_enc->flags|= CODEC_FLAG_PSNR;
2950 video_enc->me_method = me_method;
2955 video_enc->flags |= CODEC_FLAG_PASS1;
2957 video_enc->flags |= CODEC_FLAG_PASS2;
2962 /* reset some key parameters */
2964 video_codec_id = CODEC_ID_NONE;
2965 video_stream_copy = 0;
2968 static void new_audio_stream(AVFormatContext *oc)
2971 AVCodecContext *audio_enc;
2974 st = av_new_stream(oc, oc->nb_streams);
2976 fprintf(stderr, "Could not alloc stream\n");
2980 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2981 audio_bitstream_filters= NULL;
2983 #if defined(HAVE_THREADS)
2985 avcodec_thread_init(st->codec, thread_count);
2988 audio_enc = st->codec;
2989 audio_enc->codec_type = CODEC_TYPE_AUDIO;
2992 audio_enc->codec_tag= audio_codec_tag;
2994 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2995 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2996 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2998 if (audio_stream_copy) {
2999 st->stream_copy = 1;
3000 audio_enc->channels = audio_channels;
3002 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3004 for(i=0; i<opt_name_count; i++){
3006 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3007 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3008 av_set_double(audio_enc, opt_names[i], d);
3011 if (audio_codec_id != CODEC_ID_NONE)
3012 codec_id = audio_codec_id;
3013 audio_enc->codec_id = codec_id;
3015 audio_enc->bit_rate = audio_bit_rate;
3016 if (audio_qscale > QSCALE_NONE) {
3017 audio_enc->flags |= CODEC_FLAG_QSCALE;
3018 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3020 audio_enc->strict_std_compliance = strict;
3021 audio_enc->thread_count = thread_count;
3022 /* For audio codecs other than AC3 or DTS we limit */
3023 /* the number of coded channels to stereo */
3024 if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3025 && codec_id != CODEC_ID_DTS) {
3026 audio_enc->channels = 2;
3028 audio_enc->channels = audio_channels;
3030 audio_enc->sample_rate = audio_sample_rate;
3031 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3032 if (audio_language) {
3033 pstrcpy(st->language, sizeof(st->language), audio_language);
3034 av_free(audio_language);
3035 audio_language = NULL;
3038 /* reset some key parameters */
3040 audio_codec_id = CODEC_ID_NONE;
3041 audio_stream_copy = 0;
3044 static void opt_new_subtitle_stream(void)
3046 AVFormatContext *oc;
3048 AVCodecContext *subtitle_enc;
3051 if (nb_output_files <= 0) {
3052 fprintf(stderr, "At least one output file must be specified\n");
3055 oc = output_files[nb_output_files - 1];
3057 st = av_new_stream(oc, oc->nb_streams);
3059 fprintf(stderr, "Could not alloc stream\n");
3063 subtitle_enc = st->codec;
3064 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3065 if (subtitle_stream_copy) {
3066 st->stream_copy = 1;
3068 for(i=0; i<opt_name_count; i++){
3070 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3071 if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3072 av_set_double(subtitle_enc, opt_names[i], d);
3074 subtitle_enc->codec_id = subtitle_codec_id;
3077 if (subtitle_language) {
3078 pstrcpy(st->language, sizeof(st->language), subtitle_language);
3079 av_free(subtitle_language);
3080 subtitle_language = NULL;
3083 subtitle_codec_id = CODEC_ID_NONE;
3084 subtitle_stream_copy = 0;
3087 static void opt_new_audio_stream(void)
3089 AVFormatContext *oc;
3090 if (nb_output_files <= 0) {
3091 fprintf(stderr, "At least one output file must be specified\n");
3094 oc = output_files[nb_output_files - 1];
3095 new_audio_stream(oc);
3098 static void opt_new_video_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_video_stream(oc);
3109 static void opt_output_file(const char *filename)
3111 AVFormatContext *oc;
3112 int use_video, use_audio, input_has_video, input_has_audio, i;
3113 AVFormatParameters params, *ap = ¶ms;
3115 if (!strcmp(filename, "-"))
3118 oc = av_alloc_format_context();
3120 if (!file_oformat) {
3121 file_oformat = guess_format(NULL, filename, NULL);
3122 if (!file_oformat) {
3123 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3129 oc->oformat = file_oformat;
3130 pstrcpy(oc->filename, sizeof(oc->filename), filename);
3132 if (!strcmp(file_oformat->name, "ffm") &&
3133 strstart(filename, "http:", NULL)) {
3134 /* special case for files sent to ffserver: we get the stream
3135 parameters from ffserver */
3136 if (read_ffserver_streams(oc, filename) < 0) {
3137 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3141 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3142 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3144 /* disable if no corresponding type found and at least one
3146 if (nb_input_files > 0) {
3147 check_audio_video_inputs(&input_has_video, &input_has_audio);
3148 if (!input_has_video)
3150 if (!input_has_audio)
3154 /* manual disable */
3155 if (audio_disable) {
3158 if (video_disable) {
3163 new_video_stream(oc);
3167 new_audio_stream(oc);
3170 if (!oc->nb_streams) {
3171 fprintf(stderr, "No audio or video streams available\n");
3175 oc->timestamp = rec_timestamp;
3178 pstrcpy(oc->title, sizeof(oc->title), str_title);
3180 pstrcpy(oc->author, sizeof(oc->author), str_author);
3182 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3184 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3186 pstrcpy(oc->album, sizeof(oc->album), str_album);
3189 output_files[nb_output_files++] = oc;
3191 /* check filename in case of an image number is expected */
3192 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3193 if (!av_filename_number_test(oc->filename)) {
3194 print_error(oc->filename, AVERROR_NUMEXPECTED);
3199 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3200 /* test if it already exists to avoid loosing precious files */
3201 if (!file_overwrite &&
3202 (strchr(filename, ':') == NULL ||
3203 strstart(filename, "file:", NULL))) {
3204 if (url_exist(filename)) {
3207 if ( !using_stdin ) {
3208 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3211 if (toupper(c) != 'Y') {
3212 fprintf(stderr, "Not overwriting - exiting\n");
3217 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3224 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3225 fprintf(stderr, "Could not open '%s'\n", filename);
3230 memset(ap, 0, sizeof(*ap));
3231 ap->image_format = image_format;
3232 if (av_set_parameters(oc, ap) < 0) {
3233 fprintf(stderr, "%s: Invalid encoding parameters\n",
3238 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3239 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3240 oc->loop_output = loop_output;
3242 for(i=0; i<opt_name_count; i++){
3244 double d = av_get_double(avformat_opts, opt_names[i], &opt);
3245 if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3246 av_set_double(oc, opt_names[i], d);
3249 /* reset some options */
3250 file_oformat = NULL;
3251 file_iformat = NULL;
3252 image_format = NULL;
3255 /* prepare dummy protocols for grab */
3256 static void prepare_grab(void)
3258 int has_video, has_audio, i, j;
3259 AVFormatContext *oc;
3260 AVFormatContext *ic;
3261 AVFormatParameters vp1, *vp = &vp1;
3262 AVFormatParameters ap1, *ap = &ap1;
3264 /* see if audio/video inputs are needed */
3267 memset(ap, 0, sizeof(*ap));
3268 memset(vp, 0, sizeof(*vp));
3269 vp->time_base.num= 1;
3270 for(j=0;j<nb_output_files;j++) {
3271 oc = output_files[j];
3272 for(i=0;i<oc->nb_streams;i++) {
3273 AVCodecContext *enc = oc->streams[i]->codec;
3274 switch(enc->codec_type) {
3275 case CODEC_TYPE_AUDIO:
3276 if (enc->sample_rate > ap->sample_rate)
3277 ap->sample_rate = enc->sample_rate;
3278 if (enc->channels > ap->channels)
3279 ap->channels = enc->channels;
3282 case CODEC_TYPE_VIDEO:
3283 if (enc->width > vp->width)
3284 vp->width = enc->width;
3285 if (enc->height > vp->height)
3286 vp->height = enc->height;
3288 if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3289 vp->time_base = enc->time_base;
3290 vp->width += frame_leftBand + frame_rightBand;
3291 vp->width -= (frame_padleft + frame_padright);
3292 vp->height += frame_topBand + frame_bottomBand;
3293 vp->height -= (frame_padtop + frame_padbottom);
3303 if (has_video == 0 && has_audio == 0) {
3304 fprintf(stderr, "Output file must have at least one audio or video stream\n");
3309 AVInputFormat *fmt1;
3310 fmt1 = av_find_input_format(video_grab_format);
3311 vp->device = video_device;
3312 vp->channel = video_channel;
3313 vp->standard = video_standard;
3314 vp->pix_fmt = frame_pix_fmt;
3315 if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3316 fprintf(stderr, "Could not find video grab device\n");
3319 /* If not enough info to get the stream parameters, we decode the
3320 first frames to get it. */
3321 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3322 fprintf(stderr, "Could not find video grab parameters\n");
3325 /* by now video grab has one stream */
3326 ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3327 ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3328 input_files[nb_input_files] = ic;
3331 dump_format(ic, nb_input_files, "", 0);
3335 if (has_audio && audio_grab_format) {
3336 AVInputFormat *fmt1;
3337 fmt1 = av_find_input_format(audio_grab_format);
3338 ap->device = audio_device;
3339 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3340 fprintf(stderr, "Could not find audio grab device\n");
3343 input_files[nb_input_files] = ic;
3346 dump_format(ic, nb_input_files, "", 0);
3352 /* same option as mencoder */
3353 static void opt_pass(const char *pass_str)
3356 pass = atoi(pass_str);
3357 if (pass != 1 && pass != 2) {
3358 fprintf(stderr, "pass number can be only 1 or 2\n");
3364 #if defined(__MINGW32__) || defined(CONFIG_OS2)
3365 static int64_t getutime(void)
3367 return av_gettime();
3370 static int64_t getutime(void)
3372 struct rusage rusage;
3374 getrusage(RUSAGE_SELF, &rusage);
3375 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3379 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3380 extern int ffm_nopts;
3383 static void show_formats(void)
3385 AVInputFormat *ifmt;
3386 AVOutputFormat *ofmt;
3387 AVImageFormat *image_fmt;
3390 const char **pp, *last_name;
3392 printf("File formats:\n");
3397 const char *name=NULL;
3398 const char *long_name=NULL;
3400 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3401 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3402 strcmp(ofmt->name, last_name)>0){
3404 long_name= ofmt->long_name;
3408 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3409 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3410 strcmp(ifmt->name, last_name)>0){
3412 long_name= ifmt->long_name;
3415 if(name && strcmp(ifmt->name, name)==0)
3427 long_name ? long_name:" ");
3431 printf("Image formats (filename extensions, if any, follow):\n");
3432 for(image_fmt = first_image_format; image_fmt != NULL;
3433 image_fmt = image_fmt->next) {
3436 image_fmt->img_read ? "D":" ",
3437 image_fmt->img_write ? "E":" ",
3439 image_fmt->extensions ? image_fmt->extensions:" ");
3443 printf("Codecs:\n");
3449 const char *type_str;
3452 for(p = first_avcodec; p != NULL; p = p->next) {
3453 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3454 strcmp(p->name, last_name)>0){
3456 decode= encode= cap=0;
3458 if(p2 && strcmp(p->name, p2->name)==0){
3459 if(p->decode) decode=1;
3460 if(p->encode) encode=1;
3461 cap |= p->capabilities;
3466 last_name= p2->name;
3469 case CODEC_TYPE_VIDEO:
3472 case CODEC_TYPE_AUDIO:
3475 case CODEC_TYPE_SUBTITLE:
3484 decode ? "D": (/*p2->decoder ? "d":*/" "),
3487 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3488 cap & CODEC_CAP_DR1 ? "D":" ",
3489 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3491 /* if(p2->decoder && decode==0)
3492 printf(" use %s for decoding", p2->decoder->name);*/
3497 printf("Supported file protocols:\n");
3498 for(up = first_protocol; up != NULL; up = up->next)
3499 printf(" %s:", up->name);
3502 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3503 printf("Motion estimation methods:\n");
3507 if ((pp - motion_str + 1) == ME_ZERO)
3508 printf("(fastest)");
3509 else if ((pp - motion_str + 1) == ME_FULL)
3510 printf("(slowest)");
3511 else if ((pp - motion_str + 1) == ME_EPZS)
3512 printf("(default)");
3517 "Note, the names of encoders and decoders dont always match, so there are\n"
3518 "several cases where the above table shows encoder only or decoder only entries\n"
3519 "even though both encoding and decoding are supported for example, the h263\n"
3520 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3525 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3528 const char *p = str;
3535 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3542 static void opt_inter_matrix(const char *arg)
3544 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3545 parse_matrix_coeffs(inter_matrix, arg);
3548 static void opt_intra_matrix(const char *arg)
3550 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3551 parse_matrix_coeffs(intra_matrix, arg);
3554 static void opt_target(const char *arg)
3557 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3559 if(!strncmp(arg, "pal-", 4)) {
3562 } else if(!strncmp(arg, "ntsc-", 5)) {
3565 } else if(!strncmp(arg, "film-", 5)) {
3570 /* Calculate FR via float to avoid int overflow */
3571 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3574 } else if((fr == 29970) || (fr == 23976)) {
3577 /* Try to determine PAL/NTSC by peeking in the input files */
3578 if(nb_input_files) {
3580 for(j = 0; j < nb_input_files; j++) {
3581 for(i = 0; i < input_files[j]->nb_streams; i++) {
3582 AVCodecContext *c = input_files[j]->streams[i]->codec;
3583 if(c->codec_type != CODEC_TYPE_VIDEO)
3585 fr = c->time_base.den * 1000 / c->time_base.num;
3589 } else if((fr == 29970) || (fr == 23976)) {
3599 if(verbose && norm >= 0)
3600 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3604 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3605 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3606 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3610 if(!strcmp(arg, "vcd")) {
3612 opt_video_codec("mpeg1video");
3613 opt_audio_codec("mp2");
3616 opt_frame_size(norm ? "352x240" : "352x288");
3617 opt_frame_rate(frame_rates[norm]);
3618 opt_default("gop", norm ? "18" : "15");
3620 opt_default("b", "1150000");
3621 opt_default("maxrate", "1150000");
3622 opt_default("minrate", "1150000");
3623 opt_default("bufsize", "327680"); // 40*1024*8;
3625 audio_bit_rate = 224000;
3626 audio_sample_rate = 44100;
3628 opt_default("packetsize", "2324");
3629 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3631 /* We have to offset the PTS, so that it is consistent with the SCR.
3632 SCR starts at 36000, but the first two packs contain only padding
3633 and the first pack from the other stream, respectively, may also have
3634 been written before.
3635 So the real data starts at SCR 36000+3*1200. */
3636 mux_preload= (36000+3*1200) / 90000.0; //0.44
3637 } else if(!strcmp(arg, "svcd")) {
3639 opt_video_codec("mpeg2video");
3640 opt_audio_codec("mp2");
3643 opt_frame_size(norm ? "480x480" : "480x576");
3644 opt_frame_rate(frame_rates[norm]);
3645 opt_default("gop", norm ? "18" : "15");
3647 opt_default("b", "2040000");
3648 opt_default("maxrate", "2516000");
3649 opt_default("minrate", "0"); //1145000;
3650 opt_default("bufsize", "1835008"); //224*1024*8;
3651 opt_default("flags", "+SCAN_OFFSET");
3654 audio_bit_rate = 224000;
3655 audio_sample_rate = 44100;
3657 opt_default("packetsize", "2324");
3659 } else if(!strcmp(arg, "dvd")) {
3661 opt_video_codec("mpeg2video");
3662 opt_audio_codec("ac3");
3665 opt_frame_size(norm ? "720x480" : "720x576");
3666 opt_frame_rate(frame_rates[norm]);
3667 opt_default("gop", norm ? "18" : "15");
3669 opt_default("b", "6000000");
3670 opt_default("maxrate", "9000000");
3671 opt_default("minrate", "0"); //1500000;
3672 opt_default("bufsize", "1835008"); //224*1024*8;
3674 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3675 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3677 audio_bit_rate = 448000;
3678 audio_sample_rate = 48000;
3680 } else if(!strncmp(arg, "dv", 2)) {
3684 opt_frame_size(norm ? "720x480" : "720x576");
3685 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3686 (norm ? "yuv411p" : "yuv420p"));
3687 opt_frame_rate(frame_rates[norm]);
3689 audio_sample_rate = 48000;
3693 fprintf(stderr, "Unknown target: %s\n", arg);
3698 static void opt_video_bsf(const char *arg)
3700 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3701 AVBitStreamFilterContext **bsfp;
3704 fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3708 bsfp= &video_bitstream_filters;
3710 bsfp= &(*bsfp)->next;
3715 //FIXME avoid audio - video code duplication
3716 static void opt_audio_bsf(const char *arg)
3718 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3719 AVBitStreamFilterContext **bsfp;
3722 fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3726 bsfp= &audio_bitstream_filters;
3728 bsfp= &(*bsfp)->next;