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_qmin = 2;
110 static int video_qmax = 31;
111 static int video_lmin = 2*FF_QP2LAMBDA;
112 static int video_lmax = 31*FF_QP2LAMBDA;
113 static int video_mb_lmin = 2*FF_QP2LAMBDA;
114 static int video_mb_lmax = 31*FF_QP2LAMBDA;
115 static int video_qdiff = 3;
116 static float video_qsquish = 0.0;
117 static uint16_t *intra_matrix = NULL;
118 static uint16_t *inter_matrix = NULL;
119 #if 0 //experimental, (can be removed)
120 static float video_rc_qsquish=1.0;
121 static float video_rc_qmod_amp=0;
122 static int video_rc_qmod_freq=0;
124 static char *video_rc_override_string=NULL;
125 static char *video_rc_eq="tex^qComp";
126 static float video_rc_buffer_aggressivity=1.0;
127 static int me_method = ME_EPZS;
128 static int video_disable = 0;
129 static int video_discard = 0;
130 static int video_codec_id = CODEC_ID_NONE;
131 static int video_codec_tag = 0;
132 static int same_quality = 0;
133 static int do_deinterlace = 0;
134 static int workaround_bugs = FF_BUG_AUTODETECT;
135 static int packet_size = 0;
136 static int error_rate = 0;
137 static int strict = 0;
138 static int top_field_first = -1;
139 static int sc_threshold = 0;
140 static int me_threshold = 0;
141 static int mb_threshold = 0;
142 static int intra_dc_precision = 8;
143 static int me_penalty_compensation= 256;
144 static int frame_skip_threshold= 0;
145 static int frame_skip_factor= 0;
146 static int frame_skip_exp= 0;
147 static int loop_input = 0;
148 static int loop_output = AVFMT_NOOUTPUTLOOP;
149 static int qp_hist = 0;
151 static int intra_only = 0;
152 static int audio_sample_rate = 44100;
153 static int audio_bit_rate = 64000;
154 #define QSCALE_NONE -99999
155 static float audio_qscale = QSCALE_NONE;
156 static int audio_disable = 0;
157 static int audio_channels = 1;
158 static int audio_codec_id = CODEC_ID_NONE;
159 static int audio_codec_tag = 0;
160 static char *audio_language = NULL;
162 static int subtitle_codec_id = CODEC_ID_NONE;
163 static char *subtitle_language = NULL;
165 static float mux_preload= 0.5;
166 static float mux_max_delay= 0.7;
168 static int64_t recording_time = 0;
169 static int64_t start_time = 0;
170 static int64_t rec_timestamp = 0;
171 static int64_t input_ts_offset = 0;
172 static int file_overwrite = 0;
173 static char *str_title = NULL;
174 static char *str_author = NULL;
175 static char *str_copyright = NULL;
176 static char *str_comment = NULL;
177 static char *str_album = NULL;
178 static int do_benchmark = 0;
179 static int do_hex_dump = 0;
180 static int do_pkt_dump = 0;
181 static int do_psnr = 0;
182 static int do_vstats = 0;
183 static int do_pass = 0;
184 static char *pass_logfilename = NULL;
185 static int audio_stream_copy = 0;
186 static int video_stream_copy = 0;
187 static int subtitle_stream_copy = 0;
188 static int video_sync_method= 1;
189 static int audio_sync_method= 0;
190 static int copy_ts= 0;
191 static int opt_shortest = 0; //
192 static int video_global_header = 0;
194 static int rate_emu = 0;
197 static const char *video_grab_format = "bktr";
199 #ifdef CONFIG_VIDEO4LINUX2
200 static const char *video_grab_format = "video4linux2";
202 static const char *video_grab_format = "video4linux";
205 static char *video_device = NULL;
206 static char *grab_device = NULL;
207 static int video_channel = 0;
208 static char *video_standard = "ntsc";
210 static const char *audio_grab_format = "audio_device";
211 static char *audio_device = NULL;
212 static int audio_volume = 256;
214 static int using_stdin = 0;
215 static int using_vhook = 0;
216 static int verbose = 1;
217 static int thread_count= 1;
218 static int q_pressed = 0;
219 static int64_t video_size = 0;
220 static int64_t audio_size = 0;
221 static int64_t extra_size = 0;
222 static int nb_frames_dup = 0;
223 static int nb_frames_drop = 0;
224 static int input_sync;
225 static int limit_filesize = 0; //
227 static int pgmyuv_compatibility_hack=0;
228 static int dts_delta_threshold = 10;
230 static int sws_flags = SWS_BICUBIC;
232 const char **opt_names=NULL;
233 int opt_name_count=0;
234 AVCodecContext *avctx_opts;
235 AVFormatContext *avformat_opts;
237 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
238 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
239 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
241 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
243 struct AVInputStream;
245 typedef struct AVOutputStream {
246 int file_index; /* file index */
247 int index; /* stream index in the output file */
248 int source_index; /* AVInputStream index */
249 AVStream *st; /* stream in the output file */
250 int encoding_needed; /* true if encoding needed for this stream */
252 /* input pts and corresponding output pts
254 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
255 struct AVInputStream *sync_ist; /* input stream to sync against */
256 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
259 AVFrame pict_tmp; /* temporary image for resampling */
260 struct SwsContext *img_resample_ctx; /* for image resampling */
264 int topBand; /* cropping area sizes */
268 int padtop; /* padding area sizes */
275 ReSampleContext *resample; /* for audio resampling */
276 FifoBuffer fifo; /* for compression: one audio fifo per codec */
280 typedef struct AVInputStream {
284 int discard; /* true if stream data should be discarded */
285 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
286 int64_t sample_index; /* current sample */
288 int64_t start; /* time when read started */
289 unsigned long frame; /* current frame */
290 int64_t next_pts; /* synthetic pts for cases where pkt.pts
292 int64_t pts; /* current pts */
293 int is_start; /* is 1 at the start and after a discontinuity */
296 typedef struct AVInputFile {
297 int eof_reached; /* true if eof reached */
298 int ist_index; /* index of first stream in ist_table */
299 int buffer_size; /* current total buffer size */
300 int buffer_size_max; /* buffer size at which we consider we can stop
302 int nb_streams; /* nb streams we are aware of */
307 /* init terminal so that we can grab keys */
308 static struct termios oldtty;
310 static void term_exit(void)
312 tcsetattr (0, TCSANOW, &oldtty);
315 static volatile sig_atomic_t received_sigterm = 0;
318 sigterm_handler(int sig)
320 received_sigterm = sig;
324 static void term_init(void)
331 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
332 |INLCR|IGNCR|ICRNL|IXON);
333 tty.c_oflag |= OPOST;
334 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
335 tty.c_cflag &= ~(CSIZE|PARENB);
340 tcsetattr (0, TCSANOW, &tty);
342 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
343 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
344 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
346 register a function to be called at normal program termination
349 #ifdef CONFIG_BEOS_NETSERVER
350 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
354 /* read a key without blocking */
355 static int read_key(void)
359 #ifndef CONFIG_BEOS_NETSERVER
367 n = select(1, &rfds, NULL, NULL, &tv);
379 static int decode_interrupt_cb(void)
381 return q_pressed || (q_pressed = read_key() == 'q');
386 static volatile int received_sigterm = 0;
388 /* no interactive support */
389 static void term_exit(void)
393 static void term_init(void)
397 static int read_key(void)
404 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
409 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
412 /* copy stream format */
413 s->nb_streams = ic->nb_streams;
414 for(i=0;i<ic->nb_streams;i++) {
417 // FIXME: a more elegant solution is needed
418 st = av_mallocz(sizeof(AVStream));
419 memcpy(st, ic->streams[i], sizeof(AVStream));
420 st->codec = avcodec_alloc_context();
421 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
425 av_close_input_file(ic);
430 get_sync_ipts(const AVOutputStream *ost)
432 const AVInputStream *ist = ost->sync_ist;
433 return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
436 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
438 AVPacket new_pkt= *pkt;
439 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
440 &new_pkt.data, &new_pkt.size,
441 pkt->data, pkt->size,
442 pkt->flags & PKT_FLAG_KEY);
445 new_pkt.destruct= av_destruct_packet;
452 av_interleaved_write_frame(s, pkt);
455 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
457 static void do_audio_out(AVFormatContext *s,
460 unsigned char *buf, int size)
463 static uint8_t *audio_buf = NULL;
464 static uint8_t *audio_out = NULL;
465 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
467 int size_out, frame_bytes, ret;
468 AVCodecContext *enc= ost->st->codec;
470 /* SC: dynamic allocation of buffers */
472 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
474 audio_out = av_malloc(audio_out_size);
475 if (!audio_buf || !audio_out)
476 return; /* Should signal an error ! */
478 if(audio_sync_method){
479 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
480 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2);
481 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
482 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
484 //FIXME resample delay
485 if(fabs(delta) > 50){
488 byte_delta= FFMAX(byte_delta, -size);
492 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
497 static uint8_t *input_tmp= NULL;
498 input_tmp= av_realloc(input_tmp, byte_delta + size);
500 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
503 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
505 memset(input_tmp, 0, byte_delta);
506 memcpy(input_tmp + byte_delta, buf, size);
510 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
512 }else if(audio_sync_method>1){
513 int comp= clip(delta, -audio_sync_method, audio_sync_method);
514 assert(ost->audio_resample);
516 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
517 // 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));
518 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
522 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
523 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2); //FIXME wrong
525 if (ost->audio_resample) {
527 size_out = audio_resample(ost->resample,
528 (short *)buftmp, (short *)buf,
529 size / (ist->st->codec->channels * 2));
530 size_out = size_out * enc->channels * 2;
536 /* now encode as many frames as possible */
537 if (enc->frame_size > 1) {
538 /* output resampled raw samples */
539 fifo_write(&ost->fifo, buftmp, size_out,
542 frame_bytes = enc->frame_size * 2 * enc->channels;
544 while (fifo_read(&ost->fifo, audio_buf, frame_bytes,
545 &ost->fifo.rptr) == 0) {
547 av_init_packet(&pkt);
549 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
552 pkt.stream_index= ost->index;
555 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
556 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
557 pkt.flags |= PKT_FLAG_KEY;
558 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
560 ost->sync_opts += enc->frame_size;
564 av_init_packet(&pkt);
566 ost->sync_opts += size_out / (2 * enc->channels);
568 /* output a pcm frame */
569 /* XXX: change encoding codec API to avoid this ? */
570 switch(enc->codec->id) {
571 case CODEC_ID_PCM_S32LE:
572 case CODEC_ID_PCM_S32BE:
573 case CODEC_ID_PCM_U32LE:
574 case CODEC_ID_PCM_U32BE:
575 size_out = size_out << 1;
577 case CODEC_ID_PCM_S24LE:
578 case CODEC_ID_PCM_S24BE:
579 case CODEC_ID_PCM_U24LE:
580 case CODEC_ID_PCM_U24BE:
581 case CODEC_ID_PCM_S24DAUD:
582 size_out = size_out / 2 * 3;
584 case CODEC_ID_PCM_S16LE:
585 case CODEC_ID_PCM_S16BE:
586 case CODEC_ID_PCM_U16LE:
587 case CODEC_ID_PCM_U16BE:
590 size_out = size_out >> 1;
593 ret = avcodec_encode_audio(enc, audio_out, size_out,
596 pkt.stream_index= ost->index;
599 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
600 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
601 pkt.flags |= PKT_FLAG_KEY;
602 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
606 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
610 AVPicture picture_tmp;
613 dec = ist->st->codec;
615 /* deinterlace : must be done before any resize */
616 if (do_deinterlace || using_vhook) {
619 /* create temporary picture */
620 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
621 buf = av_malloc(size);
625 picture2 = &picture_tmp;
626 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
629 if(avpicture_deinterlace(picture2, picture,
630 dec->pix_fmt, dec->width, dec->height) < 0) {
631 /* if error, do not deinterlace */
637 img_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
643 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
645 if (picture != picture2)
646 *picture = *picture2;
650 /* we begin to correct av delay at this threshold */
651 #define AV_DELAY_MAX 0.100
653 static void do_subtitle_out(AVFormatContext *s,
659 static uint8_t *subtitle_out = NULL;
660 int subtitle_out_max_size = 65536;
661 int subtitle_out_size, nb, i;
665 if (pts == AV_NOPTS_VALUE) {
666 fprintf(stderr, "Subtitle packets must have a pts\n");
670 enc = ost->st->codec;
673 subtitle_out = av_malloc(subtitle_out_max_size);
676 /* Note: DVB subtitle need one packet to draw them and one other
677 packet to clear them */
678 /* XXX: signal it in the codec context ? */
679 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
684 for(i = 0; i < nb; i++) {
685 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
686 subtitle_out_max_size, sub);
688 av_init_packet(&pkt);
689 pkt.stream_index = ost->index;
690 pkt.data = subtitle_out;
691 pkt.size = subtitle_out_size;
692 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);
693 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
694 /* XXX: the pts correction is handled here. Maybe handling
695 it in the codec would be better */
697 pkt.pts += 90 * sub->start_display_time;
699 pkt.pts += 90 * sub->end_display_time;
701 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
705 static int bit_buffer_size= 1024*256;
706 static uint8_t *bit_buffer= NULL;
708 static void do_video_out(AVFormatContext *s,
714 int nb_frames, i, ret;
715 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
716 AVFrame picture_crop_temp, picture_pad_temp;
717 uint8_t *buf = NULL, *buf1 = NULL;
718 AVCodecContext *enc, *dec;
720 avcodec_get_frame_defaults(&picture_crop_temp);
721 avcodec_get_frame_defaults(&picture_pad_temp);
723 enc = ost->st->codec;
724 dec = ist->st->codec;
726 /* by default, we output a single frame */
731 if(video_sync_method){
733 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
734 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
737 else if (vdelta > 1.1)
738 nb_frames = lrintf(vdelta);
739 //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);
743 fprintf(stderr, "*** drop!\n");
744 }else if (nb_frames > 1) {
745 nb_frames_dup += nb_frames;
747 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
750 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
752 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
756 if (ost->video_crop) {
757 if (img_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
758 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
761 formatted_picture = &picture_crop_temp;
763 formatted_picture = in_picture;
766 final_picture = formatted_picture;
767 padding_src = formatted_picture;
768 resampling_dst = &ost->pict_tmp;
769 if (ost->video_pad) {
770 final_picture = &ost->pict_tmp;
771 if (ost->video_resample) {
772 if (img_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
773 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
776 resampling_dst = &picture_pad_temp;
780 if (ost->video_resample) {
782 final_picture = &ost->pict_tmp;
783 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
784 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
787 if (ost->video_pad) {
788 img_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
789 enc->height, enc->width, enc->pix_fmt,
790 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
793 /* duplicates frame if needed */
794 for(i=0;i<nb_frames;i++) {
796 av_init_packet(&pkt);
797 pkt.stream_index= ost->index;
799 if (s->oformat->flags & AVFMT_RAWPICTURE) {
800 /* raw pictures are written as AVPicture structure to
801 avoid any copies. We support temorarily the older
803 AVFrame* old_frame = enc->coded_frame;
804 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
805 pkt.data= (uint8_t *)final_picture;
806 pkt.size= sizeof(AVPicture);
807 if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
808 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
809 if(dec->coded_frame && dec->coded_frame->key_frame)
810 pkt.flags |= PKT_FLAG_KEY;
812 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
813 enc->coded_frame = old_frame;
817 big_picture= *final_picture;
818 /* better than nothing: use input picture interlaced
820 big_picture.interlaced_frame = in_picture->interlaced_frame;
821 if(avctx_opts->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
822 if(top_field_first == -1)
823 big_picture.top_field_first = in_picture->top_field_first;
825 big_picture.top_field_first = top_field_first;
828 /* handles sameq here. This is not correct because it may
829 not be a global option */
831 big_picture.quality = ist->st->quality;
833 big_picture.quality = ost->st->quality;
835 big_picture.pict_type = 0;
836 // big_picture.pts = AV_NOPTS_VALUE;
837 big_picture.pts= ost->sync_opts;
838 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
839 //av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
840 ret = avcodec_encode_video(enc,
841 bit_buffer, bit_buffer_size,
843 //enc->frame_number = enc->real_pict_num;
845 pkt.data= bit_buffer;
847 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
848 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
849 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n",
850 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
851 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
853 if(enc->coded_frame && enc->coded_frame->key_frame)
854 pkt.flags |= PKT_FLAG_KEY;
855 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
857 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
858 // enc->frame_number-1, enc->real_pict_num, ret,
860 /* if two pass, output log */
861 if (ost->logfile && enc->stats_out) {
862 fprintf(ost->logfile, "%s", enc->stats_out);
874 static double psnr(double d){
875 if(d==0) return INFINITY;
876 return -10.0*log(d)/log(10.0);
879 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
882 static FILE *fvstats=NULL;
889 double ti1, bitrate, avg_bitrate;
893 today = localtime(&today2);
894 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
897 fvstats = fopen(filename,"w");
905 enc = ost->st->codec;
906 if (enc->codec_type == CODEC_TYPE_VIDEO) {
907 frame_number = ost->frame_number;
908 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
909 if (enc->flags&CODEC_FLAG_PSNR)
910 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
912 fprintf(fvstats,"f_size= %6d ", frame_size);
913 /* compute pts value */
914 ti1 = ost->sync_opts * av_q2d(enc->time_base);
918 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
919 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
920 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
921 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
922 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
926 static void print_report(AVFormatContext **output_files,
927 AVOutputStream **ost_table, int nb_ostreams,
932 AVFormatContext *oc, *os;
935 int frame_number, vid, i;
936 double bitrate, ti1, pts;
937 static int64_t last_time = -1;
938 static int qp_histogram[52];
940 if (!is_last_report) {
942 /* display the report every 0.5 seconds */
943 cur_time = av_gettime();
944 if (last_time == -1) {
945 last_time = cur_time;
948 if ((cur_time - last_time) < 500000)
950 last_time = cur_time;
954 oc = output_files[0];
956 total_size = url_ftell(&oc->pb);
961 for(i=0;i<nb_ostreams;i++) {
963 os = output_files[ost->file_index];
964 enc = ost->st->codec;
965 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
966 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
967 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
969 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
970 frame_number = ost->frame_number;
971 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%3.1f ",
972 frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
974 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
975 if(qp_hist && enc->coded_frame){
977 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
978 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
981 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
983 if (enc->flags&CODEC_FLAG_PSNR){
985 double error, error_sum=0;
986 double scale, scale_sum=0;
987 char type[3]= {'Y','U','V'};
988 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
991 error= enc->error[j];
992 scale= enc->width*enc->height*255.0*255.0*frame_number;
994 error= enc->coded_frame->error[j];
995 scale= enc->width*enc->height*255.0*255.0;
1000 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1002 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1006 /* compute min output value */
1007 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1008 if ((pts < ti1) && (pts > 0))
1014 if (verbose || is_last_report) {
1015 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1017 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1018 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1019 (double)total_size / 1024, ti1, bitrate);
1022 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1023 nb_frames_dup, nb_frames_drop);
1026 fprintf(stderr, "%s \r", buf);
1031 if (is_last_report && verbose >= 0){
1032 int64_t raw= audio_size + video_size + extra_size;
1033 fprintf(stderr, "\n");
1034 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1038 100.0*(total_size - raw)/raw
1043 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1044 static int output_packet(AVInputStream *ist, int ist_index,
1045 AVOutputStream **ost_table, int nb_ostreams,
1046 const AVPacket *pkt)
1048 AVFormatContext *os;
1049 AVOutputStream *ost;
1053 int data_size, got_picture;
1055 void *buffer_to_free;
1056 static unsigned int samples_size= 0;
1057 static short *samples= NULL;
1058 AVSubtitle subtitle, *subtitle_to_free;
1062 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1063 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1064 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1066 // assert(ist->pts == ist->next_pts);
1080 /* decode the packet if needed */
1081 data_buf = NULL; /* fail safe */
1083 subtitle_to_free = NULL;
1084 if (ist->decoding_needed) {
1085 switch(ist->st->codec->codec_type) {
1086 case CODEC_TYPE_AUDIO:{
1088 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1089 /* XXX: could avoid copy if PCM 16 bits with same
1090 endianness as CPU */
1091 ret = avcodec_decode_audio(ist->st->codec, samples, &data_size,
1097 /* Some bug in mpeg audio decoder gives */
1098 /* data_size < 0, it seems they are overflows */
1099 if (data_size <= 0) {
1100 /* no audio frame */
1103 data_buf = (uint8_t *)samples;
1104 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1105 (ist->st->codec->sample_rate * ist->st->codec->channels);
1107 case CODEC_TYPE_VIDEO:
1108 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1109 /* XXX: allocate picture correctly */
1110 avcodec_get_frame_defaults(&picture);
1112 ret = avcodec_decode_video(ist->st->codec,
1113 &picture, &got_picture, ptr, len);
1114 ist->st->quality= picture.quality;
1118 /* no picture yet */
1119 goto discard_packet;
1121 if (ist->st->codec->time_base.num != 0) {
1122 ist->next_pts += ((int64_t)AV_TIME_BASE *
1123 ist->st->codec->time_base.num) /
1124 ist->st->codec->time_base.den;
1128 case CODEC_TYPE_SUBTITLE:
1129 ret = avcodec_decode_subtitle(ist->st->codec,
1130 &subtitle, &got_subtitle, ptr, len);
1133 if (!got_subtitle) {
1134 goto discard_packet;
1136 subtitle_to_free = &subtitle;
1143 switch(ist->st->codec->codec_type) {
1144 case CODEC_TYPE_AUDIO:
1145 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1146 (ist->st->codec->sample_rate * ist->st->codec->channels);
1148 case CODEC_TYPE_VIDEO:
1149 if (ist->st->codec->time_base.num != 0) {
1150 ist->next_pts += ((int64_t)AV_TIME_BASE *
1151 ist->st->codec->time_base.num) /
1152 ist->st->codec->time_base.den;
1162 buffer_to_free = NULL;
1163 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1164 pre_process_video_frame(ist, (AVPicture *)&picture,
1168 // preprocess audio (volume)
1169 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1170 if (audio_volume != 256) {
1173 for(i=0;i<(data_size / sizeof(short));i++) {
1174 int v = ((*volp) * audio_volume + 128) >> 8;
1175 if (v < -32768) v = -32768;
1176 if (v > 32767) v = 32767;
1182 /* frame rate emulation */
1183 if (ist->st->codec->rate_emu) {
1184 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1185 int64_t now = av_gettime() - ist->start;
1193 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1194 is the one of the next displayed one */
1195 /* XXX: add mpeg4 too ? */
1196 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1197 if (ist->st->codec->pict_type != B_TYPE) {
1199 tmp = ist->last_ip_pts;
1200 ist->last_ip_pts = ist->frac_pts.val;
1201 ist->frac_pts.val = tmp;
1205 /* if output time reached then transcode raw format,
1206 encode packets and output them */
1207 if (start_time == 0 || ist->pts >= start_time)
1208 for(i=0;i<nb_ostreams;i++) {
1212 if (ost->source_index == ist_index) {
1213 os = output_files[ost->file_index];
1216 printf("%d: got pts=%0.3f %0.3f\n", i,
1217 (double)pkt->pts / AV_TIME_BASE,
1218 ((double)ist->pts / AV_TIME_BASE) -
1219 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1221 /* set the input output pts pairs */
1222 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1224 if (ost->encoding_needed) {
1225 switch(ost->st->codec->codec_type) {
1226 case CODEC_TYPE_AUDIO:
1227 do_audio_out(os, ost, ist, data_buf, data_size);
1229 case CODEC_TYPE_VIDEO:
1230 do_video_out(os, ost, ist, &picture, &frame_size);
1231 video_size += frame_size;
1232 if (do_vstats && frame_size)
1233 do_video_stats(os, ost, frame_size);
1235 case CODEC_TYPE_SUBTITLE:
1236 do_subtitle_out(os, ost, ist, &subtitle,
1243 AVFrame avframe; //FIXME/XXX remove this
1245 av_init_packet(&opkt);
1247 /* no reencoding needed : output the packet directly */
1248 /* force the input stream PTS */
1250 avcodec_get_frame_defaults(&avframe);
1251 ost->st->codec->coded_frame= &avframe;
1252 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1254 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1255 audio_size += data_size;
1256 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1257 video_size += data_size;
1261 opkt.stream_index= ost->index;
1262 if(pkt->pts != AV_NOPTS_VALUE)
1263 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);
1265 opkt.pts= AV_NOPTS_VALUE;
1269 if (pkt->dts == AV_NOPTS_VALUE)
1270 dts = ist->next_pts;
1272 dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1273 opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
1275 opkt.flags= pkt->flags;
1277 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1278 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1279 opkt.destruct= av_destruct_packet;
1281 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1282 ost->st->codec->frame_number++;
1283 ost->frame_number++;
1284 av_free_packet(&opkt);
1288 av_free(buffer_to_free);
1289 /* XXX: allocate the subtitles in the codec ? */
1290 if (subtitle_to_free) {
1291 if (subtitle_to_free->rects != NULL) {
1292 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1293 av_free(subtitle_to_free->rects[i].bitmap);
1294 av_free(subtitle_to_free->rects[i].rgba_palette);
1296 av_freep(&subtitle_to_free->rects);
1298 subtitle_to_free->num_rects = 0;
1299 subtitle_to_free = NULL;
1306 for(i=0;i<nb_ostreams;i++) {
1308 if (ost->source_index == ist_index) {
1309 AVCodecContext *enc= ost->st->codec;
1310 os = output_files[ost->file_index];
1312 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1314 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1317 if (ost->encoding_needed) {
1321 av_init_packet(&pkt);
1322 pkt.stream_index= ost->index;
1324 switch(ost->st->codec->codec_type) {
1325 case CODEC_TYPE_AUDIO:
1326 fifo_bytes = fifo_size(&ost->fifo, NULL);
1328 /* encode any samples remaining in fifo */
1329 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1330 int fs_tmp = enc->frame_size;
1331 enc->frame_size = fifo_bytes / (2 * enc->channels);
1332 if(fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes,
1333 &ost->fifo.rptr) == 0) {
1334 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1336 enc->frame_size = fs_tmp;
1339 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1342 pkt.flags |= PKT_FLAG_KEY;
1344 case CODEC_TYPE_VIDEO:
1345 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1347 if(enc->coded_frame && enc->coded_frame->key_frame)
1348 pkt.flags |= PKT_FLAG_KEY;
1349 if (ost->logfile && enc->stats_out) {
1350 fprintf(ost->logfile, "%s", enc->stats_out);
1359 pkt.data= bit_buffer;
1361 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1362 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1363 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1377 * The following code is the main loop of the file converter
1379 static int av_encode(AVFormatContext **output_files,
1380 int nb_output_files,
1381 AVFormatContext **input_files,
1383 AVStreamMap *stream_maps, int nb_stream_maps)
1385 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1386 AVFormatContext *is, *os;
1387 AVCodecContext *codec, *icodec;
1388 AVOutputStream *ost, **ost_table = NULL;
1389 AVInputStream *ist, **ist_table = NULL;
1390 AVInputFile *file_table;
1391 AVFormatContext *stream_no_data;
1394 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1398 /* input stream init */
1400 for(i=0;i<nb_input_files;i++) {
1401 is = input_files[i];
1402 file_table[i].ist_index = j;
1403 file_table[i].nb_streams = is->nb_streams;
1404 j += is->nb_streams;
1408 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1412 for(i=0;i<nb_istreams;i++) {
1413 ist = av_mallocz(sizeof(AVInputStream));
1419 for(i=0;i<nb_input_files;i++) {
1420 is = input_files[i];
1421 for(k=0;k<is->nb_streams;k++) {
1422 ist = ist_table[j++];
1423 ist->st = is->streams[k];
1424 ist->file_index = i;
1426 ist->discard = 1; /* the stream is discarded by default
1429 if (ist->st->codec->rate_emu) {
1430 ist->start = av_gettime();
1436 /* output stream init */
1438 for(i=0;i<nb_output_files;i++) {
1439 os = output_files[i];
1440 nb_ostreams += os->nb_streams;
1442 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1443 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1447 /* Sanity check the mapping args -- do the input files & streams exist? */
1448 for(i=0;i<nb_stream_maps;i++) {
1449 int fi = stream_maps[i].file_index;
1450 int si = stream_maps[i].stream_index;
1452 if (fi < 0 || fi > nb_input_files - 1 ||
1453 si < 0 || si > file_table[fi].nb_streams - 1) {
1454 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1457 fi = stream_maps[i].sync_file_index;
1458 si = stream_maps[i].sync_stream_index;
1459 if (fi < 0 || fi > nb_input_files - 1 ||
1460 si < 0 || si > file_table[fi].nb_streams - 1) {
1461 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1466 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1469 for(i=0;i<nb_ostreams;i++) {
1470 ost = av_mallocz(sizeof(AVOutputStream));
1477 for(k=0;k<nb_output_files;k++) {
1478 os = output_files[k];
1479 for(i=0;i<os->nb_streams;i++) {
1481 ost = ost_table[n++];
1482 ost->file_index = k;
1484 ost->st = os->streams[i];
1485 if (nb_stream_maps > 0) {
1486 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1487 stream_maps[n-1].stream_index;
1489 /* Sanity check that the stream types match */
1490 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1491 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1492 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1493 ost->file_index, ost->index);
1498 /* get corresponding input stream index : we select the first one with the right type */
1500 for(j=0;j<nb_istreams;j++) {
1503 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1504 ost->source_index = j;
1511 /* try again and reuse existing stream */
1512 for(j=0;j<nb_istreams;j++) {
1514 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1515 ost->source_index = j;
1520 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1521 ost->file_index, ost->index);
1526 ist = ist_table[ost->source_index];
1528 ost->sync_ist = (nb_stream_maps > 0) ?
1529 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1530 stream_maps[n-1].sync_stream_index] : ist;
1534 /* for each output stream, we compute the right encoding parameters */
1535 for(i=0;i<nb_ostreams;i++) {
1537 ist = ist_table[ost->source_index];
1539 codec = ost->st->codec;
1540 icodec = ist->st->codec;
1542 if (ost->st->stream_copy) {
1543 /* if stream_copy is selected, no need to decode or encode */
1544 codec->codec_id = icodec->codec_id;
1545 codec->codec_type = icodec->codec_type;
1546 if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1547 codec->bit_rate = icodec->bit_rate;
1548 codec->extradata= icodec->extradata;
1549 codec->extradata_size= icodec->extradata_size;
1550 codec->time_base = icodec->time_base;
1551 switch(codec->codec_type) {
1552 case CODEC_TYPE_AUDIO:
1553 codec->sample_rate = icodec->sample_rate;
1554 codec->channels = icodec->channels;
1555 codec->frame_size = icodec->frame_size;
1556 codec->block_align= icodec->block_align;
1558 case CODEC_TYPE_VIDEO:
1559 codec->pix_fmt = icodec->pix_fmt;
1560 codec->width = icodec->width;
1561 codec->height = icodec->height;
1562 codec->has_b_frames = icodec->has_b_frames;
1564 case CODEC_TYPE_SUBTITLE:
1570 switch(codec->codec_type) {
1571 case CODEC_TYPE_AUDIO:
1572 if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1575 if (codec->channels == icodec->channels &&
1576 codec->sample_rate == icodec->sample_rate) {
1577 ost->audio_resample = 0;
1579 if (codec->channels != icodec->channels &&
1580 (icodec->codec_id == CODEC_ID_AC3 ||
1581 icodec->codec_id == CODEC_ID_DTS)) {
1582 /* Special case for 5:1 AC3 and DTS input */
1583 /* and mono or stereo output */
1584 /* Request specific number of channels */
1585 icodec->channels = codec->channels;
1586 if (codec->sample_rate == icodec->sample_rate)
1587 ost->audio_resample = 0;
1589 ost->audio_resample = 1;
1592 ost->audio_resample = 1;
1595 if(audio_sync_method>1)
1596 ost->audio_resample = 1;
1598 if(ost->audio_resample){
1599 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1600 codec->sample_rate, icodec->sample_rate);
1602 printf("Can't resample. Aborting.\n");
1606 ist->decoding_needed = 1;
1607 ost->encoding_needed = 1;
1609 case CODEC_TYPE_VIDEO:
1610 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1611 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1612 ost->video_resample = ((codec->width != icodec->width -
1613 (frame_leftBand + frame_rightBand) +
1614 (frame_padleft + frame_padright)) ||
1615 (codec->height != icodec->height -
1616 (frame_topBand + frame_bottomBand) +
1617 (frame_padtop + frame_padbottom)) ||
1618 (codec->pix_fmt != icodec->pix_fmt));
1619 if (ost->video_crop) {
1620 ost->topBand = frame_topBand;
1621 ost->leftBand = frame_leftBand;
1623 if (ost->video_pad) {
1624 ost->padtop = frame_padtop;
1625 ost->padleft = frame_padleft;
1626 ost->padbottom = frame_padbottom;
1627 ost->padright = frame_padright;
1628 if (!ost->video_resample) {
1629 avcodec_get_frame_defaults(&ost->pict_tmp);
1630 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1631 codec->width, codec->height ) )
1635 if (ost->video_resample) {
1636 avcodec_get_frame_defaults(&ost->pict_tmp);
1637 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1638 codec->width, codec->height ) )
1641 ost->img_resample_ctx = sws_getContext(
1642 icodec->width - (frame_leftBand + frame_rightBand),
1643 icodec->height - (frame_topBand + frame_bottomBand),
1645 codec->width - (frame_padleft + frame_padright),
1646 codec->height - (frame_padtop + frame_padbottom),
1648 sws_flags, NULL, NULL, NULL);
1649 if (ost->img_resample_ctx == NULL) {
1650 fprintf(stderr, "Cannot get resampling context\n");
1653 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1655 ost->encoding_needed = 1;
1656 ist->decoding_needed = 1;
1658 case CODEC_TYPE_SUBTITLE:
1659 ost->encoding_needed = 1;
1660 ist->decoding_needed = 1;
1667 if (ost->encoding_needed &&
1668 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1669 char logfilename[1024];
1674 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1676 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1677 if (codec->flags & CODEC_FLAG_PASS1) {
1678 f = fopen(logfilename, "w");
1680 perror(logfilename);
1685 /* read the log file */
1686 f = fopen(logfilename, "r");
1688 perror(logfilename);
1691 fseek(f, 0, SEEK_END);
1693 fseek(f, 0, SEEK_SET);
1694 logbuffer = av_malloc(size + 1);
1696 fprintf(stderr, "Could not allocate log buffer\n");
1699 size = fread(logbuffer, 1, size, f);
1701 logbuffer[size] = '\0';
1702 codec->stats_in = logbuffer;
1706 if(codec->codec_type == CODEC_TYPE_VIDEO){
1707 int size= codec->width * codec->height;
1708 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1713 bit_buffer = av_malloc(bit_buffer_size);
1717 /* dump the file output parameters - cannot be done before in case
1719 for(i=0;i<nb_output_files;i++) {
1720 dump_format(output_files[i], i, output_files[i]->filename, 1);
1723 /* dump the stream mapping */
1725 fprintf(stderr, "Stream mapping:\n");
1726 for(i=0;i<nb_ostreams;i++) {
1728 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1729 ist_table[ost->source_index]->file_index,
1730 ist_table[ost->source_index]->index,
1733 if (ost->sync_ist != ist_table[ost->source_index])
1734 fprintf(stderr, " [sync #%d.%d]",
1735 ost->sync_ist->file_index,
1736 ost->sync_ist->index);
1737 fprintf(stderr, "\n");
1741 /* open each encoder */
1742 for(i=0;i<nb_ostreams;i++) {
1744 if (ost->encoding_needed) {
1746 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1748 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1749 ost->file_index, ost->index);
1752 if (avcodec_open(ost->st->codec, codec) < 0) {
1753 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1754 ost->file_index, ost->index);
1757 extra_size += ost->st->codec->extradata_size;
1761 /* open each decoder */
1762 for(i=0;i<nb_istreams;i++) {
1764 if (ist->decoding_needed) {
1766 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1768 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1769 ist->st->codec->codec_id, ist->file_index, ist->index);
1772 if (avcodec_open(ist->st->codec, codec) < 0) {
1773 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1774 ist->file_index, ist->index);
1777 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1778 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1783 for(i=0;i<nb_istreams;i++) {
1785 is = input_files[ist->file_index];
1787 ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1788 if(ist->st->start_time == AV_NOPTS_VALUE)
1790 if(input_files_ts_offset[ist->file_index])
1791 ist->next_pts= AV_NOPTS_VALUE;
1795 /* compute buffer size max (should use a complete heuristic) */
1796 for(i=0;i<nb_input_files;i++) {
1797 file_table[i].buffer_size_max = 2048;
1800 /* set meta data information from input file if required */
1801 for (i=0;i<nb_meta_data_maps;i++) {
1802 AVFormatContext *out_file;
1803 AVFormatContext *in_file;
1805 int out_file_index = meta_data_maps[i].out_file;
1806 int in_file_index = meta_data_maps[i].in_file;
1807 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1808 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1812 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1813 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1818 out_file = output_files[out_file_index];
1819 in_file = input_files[in_file_index];
1821 strcpy(out_file->title, in_file->title);
1822 strcpy(out_file->author, in_file->author);
1823 strcpy(out_file->copyright, in_file->copyright);
1824 strcpy(out_file->comment, in_file->comment);
1825 strcpy(out_file->album, in_file->album);
1826 out_file->year = in_file->year;
1827 out_file->track = in_file->track;
1828 strcpy(out_file->genre, in_file->genre);
1831 /* open files and write file headers */
1832 for(i=0;i<nb_output_files;i++) {
1833 os = output_files[i];
1834 if (av_write_header(os) < 0) {
1835 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1842 if ( !using_stdin && verbose >= 0) {
1843 fprintf(stderr, "Press [q] to stop encoding\n");
1844 url_set_interrupt_cb(decode_interrupt_cb);
1852 for(; received_sigterm == 0;) {
1853 int file_index, ist_index;
1861 /* if 'q' pressed, exits */
1865 /* read_key() returns 0 on EOF */
1871 /* select the stream that we must read now by looking at the
1872 smallest output pts */
1874 for(i=0;i<nb_ostreams;i++) {
1877 os = output_files[ost->file_index];
1878 ist = ist_table[ost->source_index];
1879 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1880 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1882 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1883 ipts = (double)ist->pts;
1884 if (!file_table[ist->file_index].eof_reached){
1885 if(ipts < ipts_min) {
1887 if(input_sync ) file_index = ist->file_index;
1889 if(opts < opts_min) {
1891 if(!input_sync) file_index = ist->file_index;
1894 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1899 /* if none, if is finished */
1900 if (file_index < 0) {
1904 /* finish if recording time exhausted */
1905 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1908 /* finish if limit size exhausted */
1909 if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1912 /* read a frame from it and output it in the fifo */
1913 is = input_files[file_index];
1914 if (av_read_frame(is, &pkt) < 0) {
1915 file_table[file_index].eof_reached = 1;
1916 if (opt_shortest) break; else continue; //
1920 stream_no_data = is;
1925 av_pkt_dump(stdout, &pkt, do_hex_dump);
1927 /* the following test is needed in case new streams appear
1928 dynamically in stream : we ignore them */
1929 if (pkt.stream_index >= file_table[file_index].nb_streams)
1930 goto discard_packet;
1931 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1932 ist = ist_table[ist_index];
1934 goto discard_packet;
1936 // 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);
1937 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1938 int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1939 if(ABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1940 input_files_ts_offset[ist->file_index]-= delta;
1942 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1943 for(i=0; i<file_table[file_index].nb_streams; i++){
1944 int index= file_table[file_index].ist_index + i;
1945 ist_table[index]->next_pts += delta;
1946 ist_table[index]->is_start=1;
1951 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1952 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1955 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1956 ist->file_index, ist->index);
1958 av_free_packet(&pkt);
1963 av_free_packet(&pkt);
1965 /* dump report by using the output first video and audio streams */
1966 print_report(output_files, ost_table, nb_ostreams, 0);
1969 /* at the end of stream, we must flush the decoder buffers */
1970 for(i=0;i<nb_istreams;i++) {
1972 if (ist->decoding_needed) {
1973 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1979 /* write the trailer if needed and close file */
1980 for(i=0;i<nb_output_files;i++) {
1981 os = output_files[i];
1982 av_write_trailer(os);
1985 /* dump report by using the first video and audio streams */
1986 print_report(output_files, ost_table, nb_ostreams, 1);
1988 /* close each encoder */
1989 for(i=0;i<nb_ostreams;i++) {
1991 if (ost->encoding_needed) {
1992 av_freep(&ost->st->codec->stats_in);
1993 avcodec_close(ost->st->codec);
1997 /* close each decoder */
1998 for(i=0;i<nb_istreams;i++) {
2000 if (ist->decoding_needed) {
2001 avcodec_close(ist->st->codec);
2009 av_freep(&bit_buffer);
2010 av_free(file_table);
2013 for(i=0;i<nb_istreams;i++) {
2020 for(i=0;i<nb_ostreams;i++) {
2024 fclose(ost->logfile);
2025 ost->logfile = NULL;
2027 fifo_free(&ost->fifo); /* works even if fifo is not
2028 initialized but set to zero */
2029 av_free(ost->pict_tmp.data[0]);
2030 if (ost->video_resample)
2031 sws_freeContext(ost->img_resample_ctx);
2032 if (ost->audio_resample)
2033 audio_resample_close(ost->resample);
2046 int file_read(const char *filename)
2049 unsigned char buffer[1024];
2052 if (url_open(&h, filename, O_RDONLY) < 0) {
2053 printf("could not open '%s'\n", filename);
2057 len = url_read(h, buffer, sizeof(buffer));
2060 for(i=0;i<len;i++) putchar(buffer[i]);
2067 static void opt_image_format(const char *arg)
2071 for(f = first_image_format; f != NULL; f = f->next) {
2072 if (!strcmp(arg, f->name))
2076 fprintf(stderr, "Unknown image format: '%s'\n", arg);
2082 static void opt_format(const char *arg)
2084 /* compatibility stuff for pgmyuv */
2085 if (!strcmp(arg, "pgmyuv")) {
2086 pgmyuv_compatibility_hack=1;
2087 // opt_image_format(arg);
2091 file_iformat = av_find_input_format(arg);
2092 file_oformat = guess_format(arg, NULL, NULL);
2093 if (!file_iformat && !file_oformat) {
2094 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2099 static void opt_video_rc_eq(char *arg)
2104 static void opt_video_rc_override_string(char *arg)
2106 video_rc_override_string = arg;
2110 static void opt_workaround_bugs(const char *arg)
2112 workaround_bugs = atoi(arg);
2115 static void opt_me_threshold(const char *arg)
2117 me_threshold = atoi(arg);
2120 static void opt_mb_threshold(const char *arg)
2122 mb_threshold = atoi(arg);
2125 static void opt_verbose(const char *arg)
2127 verbose = atoi(arg);
2128 av_log_set_level(atoi(arg));
2131 static void opt_frame_rate(const char *arg)
2133 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2134 fprintf(stderr, "Incorrect frame rate\n");
2139 static void opt_frame_crop_top(const char *arg)
2141 frame_topBand = atoi(arg);
2142 if (frame_topBand < 0) {
2143 fprintf(stderr, "Incorrect top crop size\n");
2146 if ((frame_topBand % 2) != 0) {
2147 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2150 if ((frame_topBand) >= frame_height){
2151 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2154 frame_height -= frame_topBand;
2157 static void opt_frame_crop_bottom(const char *arg)
2159 frame_bottomBand = atoi(arg);
2160 if (frame_bottomBand < 0) {
2161 fprintf(stderr, "Incorrect bottom crop size\n");
2164 if ((frame_bottomBand % 2) != 0) {
2165 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2168 if ((frame_bottomBand) >= frame_height){
2169 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2172 frame_height -= frame_bottomBand;
2175 static void opt_frame_crop_left(const char *arg)
2177 frame_leftBand = atoi(arg);
2178 if (frame_leftBand < 0) {
2179 fprintf(stderr, "Incorrect left crop size\n");
2182 if ((frame_leftBand % 2) != 0) {
2183 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2186 if ((frame_leftBand) >= frame_width){
2187 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2190 frame_width -= frame_leftBand;
2193 static void opt_frame_crop_right(const char *arg)
2195 frame_rightBand = atoi(arg);
2196 if (frame_rightBand < 0) {
2197 fprintf(stderr, "Incorrect right crop size\n");
2200 if ((frame_rightBand % 2) != 0) {
2201 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2204 if ((frame_rightBand) >= frame_width){
2205 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2208 frame_width -= frame_rightBand;
2211 static void opt_frame_size(const char *arg)
2213 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2214 fprintf(stderr, "Incorrect frame size\n");
2217 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2218 fprintf(stderr, "Frame size must be a multiple of 2\n");
2224 #define SCALEBITS 10
2225 #define ONE_HALF (1 << (SCALEBITS - 1))
2226 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2228 #define RGB_TO_Y(r, g, b) \
2229 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2230 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2232 #define RGB_TO_U(r1, g1, b1, shift)\
2233 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2234 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2236 #define RGB_TO_V(r1, g1, b1, shift)\
2237 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2238 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2240 static void opt_pad_color(const char *arg) {
2241 /* Input is expected to be six hex digits similar to
2242 how colors are expressed in html tags (but without the #) */
2243 int rgb = strtol(arg, NULL, 16);
2247 g = ((rgb >> 8) & 255);
2250 padcolor[0] = RGB_TO_Y(r,g,b);
2251 padcolor[1] = RGB_TO_U(r,g,b,0);
2252 padcolor[2] = RGB_TO_V(r,g,b,0);
2255 static void opt_frame_pad_top(const char *arg)
2257 frame_padtop = atoi(arg);
2258 if (frame_padtop < 0) {
2259 fprintf(stderr, "Incorrect top pad size\n");
2262 if ((frame_padtop % 2) != 0) {
2263 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2268 static void opt_frame_pad_bottom(const char *arg)
2270 frame_padbottom = atoi(arg);
2271 if (frame_padbottom < 0) {
2272 fprintf(stderr, "Incorrect bottom pad size\n");
2275 if ((frame_padbottom % 2) != 0) {
2276 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2282 static void opt_frame_pad_left(const char *arg)
2284 frame_padleft = atoi(arg);
2285 if (frame_padleft < 0) {
2286 fprintf(stderr, "Incorrect left pad size\n");
2289 if ((frame_padleft % 2) != 0) {
2290 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2296 static void opt_frame_pad_right(const char *arg)
2298 frame_padright = atoi(arg);
2299 if (frame_padright < 0) {
2300 fprintf(stderr, "Incorrect right pad size\n");
2303 if ((frame_padright % 2) != 0) {
2304 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2310 static void opt_frame_pix_fmt(const char *arg)
2312 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2315 static void opt_frame_aspect_ratio(const char *arg)
2321 p = strchr(arg, ':');
2323 x = strtol(arg, (char **)&arg, 10);
2325 y = strtol(arg+1, (char **)&arg, 10);
2327 ar = (double)x / (double)y;
2329 ar = strtod(arg, (char **)&arg);
2332 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2335 frame_aspect_ratio = ar;
2338 static void opt_qscale(const char *arg)
2340 video_qscale = atof(arg);
2341 if (video_qscale <= 0 ||
2342 video_qscale > 255) {
2343 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2348 static void opt_qsquish(const char *arg)
2350 video_qsquish = atof(arg);
2351 if (video_qsquish < 0.0 ||
2352 video_qsquish > 99.0) {
2353 fprintf(stderr, "qsquish must be >= 0.0 and <= 99.0\n");
2358 static void opt_lmax(const char *arg)
2360 video_lmax = atof(arg)*FF_QP2LAMBDA;
2363 static void opt_lmin(const char *arg)
2365 video_lmin = atof(arg)*FF_QP2LAMBDA;
2368 static void opt_qmin(const char *arg)
2370 video_qmin = atoi(arg);
2371 if (video_qmin < 1 ||
2373 fprintf(stderr, "qmin must be >= 1 and <= 51\n");
2378 static void opt_qmax(const char *arg)
2380 video_qmax = atoi(arg);
2381 if (video_qmax < 1 ||
2383 fprintf(stderr, "qmax must be >= 1 and <= 51\n");
2388 static void opt_mb_lmin(const char *arg)
2390 video_mb_lmin = atof(arg)*FF_QP2LAMBDA;
2391 if (video_mb_lmin < 1 ||
2392 video_mb_lmin > FF_LAMBDA_MAX) {
2393 fprintf(stderr, "mblmin must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2398 static void opt_mb_lmax(const char *arg)
2400 video_mb_lmax = atof(arg)*FF_QP2LAMBDA;
2401 if (video_mb_lmax < 1 ||
2402 video_mb_lmax > FF_LAMBDA_MAX) {
2403 fprintf(stderr, "mblmax must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2408 static void opt_qdiff(const char *arg)
2410 video_qdiff = atoi(arg);
2411 if (video_qdiff < 0 ||
2413 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2418 static void opt_packet_size(const char *arg)
2420 packet_size= atoi(arg);
2423 static void opt_error_rate(const char *arg)
2425 error_rate= atoi(arg);
2428 static void opt_strict(const char *arg)
2433 static void opt_top_field_first(const char *arg)
2435 top_field_first= atoi(arg);
2438 static void opt_sc_threshold(const char *arg)
2440 sc_threshold= atoi(arg);
2443 static void opt_thread_count(const char *arg)
2445 thread_count= atoi(arg);
2446 #if !defined(HAVE_THREADS)
2448 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2452 static void opt_audio_bitrate(const char *arg)
2454 audio_bit_rate = atoi(arg) * 1000;
2457 static void opt_audio_rate(const char *arg)
2459 audio_sample_rate = atoi(arg);
2462 static void opt_audio_channels(const char *arg)
2464 audio_channels = atoi(arg);
2467 static void opt_video_device(const char *arg)
2469 video_device = av_strdup(arg);
2472 static void opt_grab_device(const char *arg)
2474 grab_device = av_strdup(arg);
2477 static void opt_video_channel(const char *arg)
2479 video_channel = strtol(arg, NULL, 0);
2482 static void opt_video_standard(const char *arg)
2484 video_standard = av_strdup(arg);
2487 static void opt_audio_device(const char *arg)
2489 audio_device = av_strdup(arg);
2492 static void opt_codec(int *pstream_copy, int *pcodec_id,
2493 int codec_type, const char *arg)
2497 if (!strcmp(arg, "copy")) {
2502 if (!strcmp(p->name, arg) && p->type == codec_type)
2507 fprintf(stderr, "Unknown codec '%s'\n", arg);
2515 static void opt_audio_codec(const char *arg)
2517 opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2520 static void opt_audio_tag(const char *arg)
2523 audio_codec_tag= strtol(arg, &tail, 0);
2526 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2529 static void opt_video_tag(const char *arg)
2532 video_codec_tag= strtol(arg, &tail, 0);
2535 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2538 static void add_frame_hooker(const char *arg)
2543 char *args = av_strdup(arg);
2547 argv[0] = strtok(args, " ");
2548 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2551 i = frame_hook_add(argc, argv);
2554 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2559 const char *motion_str[] = {
2572 static void opt_motion_estimation(const char *arg)
2578 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2581 if (!strcmp(*p, arg))
2585 me_method = (p - motion_str) + 1;
2588 static void opt_video_codec(const char *arg)
2590 opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2593 static void opt_subtitle_codec(const char *arg)
2595 opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2598 static void opt_map(const char *arg)
2604 m = &stream_maps[nb_stream_maps++];
2606 m->file_index = strtol(arg, (char **)&p, 0);
2610 m->stream_index = strtol(p, (char **)&p, 0);
2613 m->sync_file_index = strtol(p, (char **)&p, 0);
2616 m->sync_stream_index = strtol(p, (char **)&p, 0);
2618 m->sync_file_index = m->file_index;
2619 m->sync_stream_index = m->stream_index;
2623 static void opt_map_meta_data(const char *arg)
2629 m = &meta_data_maps[nb_meta_data_maps++];
2631 m->out_file = strtol(arg, (char **)&p, 0);
2635 m->in_file = strtol(p, (char **)&p, 0);
2638 static void opt_recording_time(const char *arg)
2640 recording_time = parse_date(arg, 1);
2643 static void opt_start_time(const char *arg)
2645 start_time = parse_date(arg, 1);
2648 static void opt_rec_timestamp(const char *arg)
2650 rec_timestamp = parse_date(arg, 0) / 1000000;
2653 static void opt_input_ts_offset(const char *arg)
2655 input_ts_offset = parse_date(arg, 1);
2658 static void opt_input_file(const char *filename)
2660 AVFormatContext *ic;
2661 AVFormatParameters params, *ap = ¶ms;
2662 int err, i, ret, rfps, rfps_base;
2665 if (!strcmp(filename, "-"))
2668 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2669 !strcmp( filename, "/dev/stdin" );
2671 /* get default parameters from command line */
2672 ic = av_alloc_format_context();
2674 memset(ap, 0, sizeof(*ap));
2675 ap->prealloced_context = 1;
2676 ap->sample_rate = audio_sample_rate;
2677 ap->channels = audio_channels;
2678 ap->time_base.den = frame_rate;
2679 ap->time_base.num = frame_rate_base;
2680 ap->width = frame_width + frame_padleft + frame_padright;
2681 ap->height = frame_height + frame_padtop + frame_padbottom;
2682 ap->image_format = image_format;
2683 ap->pix_fmt = frame_pix_fmt;
2684 ap->device = grab_device;
2685 ap->channel = video_channel;
2686 ap->standard = video_standard;
2687 ap->video_codec_id = video_codec_id;
2688 ap->audio_codec_id = audio_codec_id;
2689 if(pgmyuv_compatibility_hack)
2690 ap->video_codec_id= CODEC_ID_PGMYUV;
2692 for(i=0; i<opt_name_count; i++){
2694 double d= av_get_double(avformat_opts, opt_names[i], &opt);
2695 if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2696 av_set_double(ic, opt_names[i], d);
2698 /* open the input file with generic libav function */
2699 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2701 print_error(filename, err);
2705 ic->loop_input = loop_input;
2707 /* If not enough info to get the stream parameters, we decode the
2708 first frames to get it. (used in mpeg case for example) */
2709 ret = av_find_stream_info(ic);
2710 if (ret < 0 && verbose >= 0) {
2711 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2715 timestamp = start_time;
2716 /* add the stream start time */
2717 if (ic->start_time != AV_NOPTS_VALUE)
2718 timestamp += ic->start_time;
2720 /* if seeking requested, we execute it */
2721 if (start_time != 0) {
2722 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2724 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2725 filename, (double)timestamp / AV_TIME_BASE);
2727 /* reset seek info */
2731 /* update the current parameters so that they match the one of the input stream */
2732 for(i=0;i<ic->nb_streams;i++) {
2734 AVCodecContext *enc = ic->streams[i]->codec;
2735 #if defined(HAVE_THREADS)
2737 avcodec_thread_init(enc, thread_count);
2739 enc->thread_count= thread_count;
2740 switch(enc->codec_type) {
2741 case CODEC_TYPE_AUDIO:
2742 for(j=0; j<opt_name_count; j++){
2744 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2745 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2746 av_set_double(enc, opt_names[j], d);
2748 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2749 audio_channels = enc->channels;
2750 audio_sample_rate = enc->sample_rate;
2752 ic->streams[i]->discard= AVDISCARD_ALL;
2754 case CODEC_TYPE_VIDEO:
2755 for(j=0; j<opt_name_count; j++){
2757 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2758 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2759 av_set_double(enc, opt_names[j], d);
2761 frame_height = enc->height;
2762 frame_width = enc->width;
2763 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2764 frame_pix_fmt = enc->pix_fmt;
2765 rfps = ic->streams[i]->r_frame_rate.num;
2766 rfps_base = ic->streams[i]->r_frame_rate.den;
2767 enc->workaround_bugs = workaround_bugs;
2768 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2770 enc->debug |= FF_DEBUG_MV;
2772 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2775 fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2776 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2778 (float)rfps / rfps_base, rfps, rfps_base);
2780 /* update the current frame rate to match the stream frame rate */
2782 frame_rate_base = rfps_base;
2784 enc->rate_emu = rate_emu;
2786 ic->streams[i]->discard= AVDISCARD_ALL;
2787 else if(video_discard)
2788 ic->streams[i]->discard= video_discard;
2790 case CODEC_TYPE_DATA:
2792 case CODEC_TYPE_SUBTITLE:
2794 case CODEC_TYPE_UNKNOWN:
2801 input_files[nb_input_files] = ic;
2802 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2803 /* dump the file content */
2805 dump_format(ic, nb_input_files, filename, 0);
2808 file_iformat = NULL;
2809 file_oformat = NULL;
2810 image_format = NULL;
2818 static void opt_grab(const char *arg)
2820 file_iformat = av_find_input_format(arg);
2824 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2826 int has_video, has_audio, i, j;
2827 AVFormatContext *ic;
2831 for(j=0;j<nb_input_files;j++) {
2832 ic = input_files[j];
2833 for(i=0;i<ic->nb_streams;i++) {
2834 AVCodecContext *enc = ic->streams[i]->codec;
2835 switch(enc->codec_type) {
2836 case CODEC_TYPE_AUDIO:
2839 case CODEC_TYPE_VIDEO:
2842 case CODEC_TYPE_DATA:
2843 case CODEC_TYPE_UNKNOWN:
2844 case CODEC_TYPE_SUBTITLE:
2851 *has_video_ptr = has_video;
2852 *has_audio_ptr = has_audio;
2855 static void new_video_stream(AVFormatContext *oc)
2858 AVCodecContext *video_enc;
2861 st = av_new_stream(oc, oc->nb_streams);
2863 fprintf(stderr, "Could not alloc stream\n");
2866 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2867 video_bitstream_filters= NULL;
2869 #if defined(HAVE_THREADS)
2871 avcodec_thread_init(st->codec, thread_count);
2874 video_enc = st->codec;
2877 video_enc->codec_tag= video_codec_tag;
2879 if( (video_global_header&1)
2880 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2881 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2882 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2884 if(video_global_header&2){
2885 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2886 avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2889 if (video_stream_copy) {
2890 st->stream_copy = 1;
2891 video_enc->codec_type = CODEC_TYPE_VIDEO;
2897 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2898 if (video_codec_id != CODEC_ID_NONE)
2899 codec_id = video_codec_id;
2901 video_enc->codec_id = codec_id;
2902 codec = avcodec_find_encoder(codec_id);
2904 for(i=0; i<opt_name_count; i++){
2906 double d= av_get_double(avctx_opts, opt_names[i], &opt);
2907 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2908 av_set_double(video_enc, opt_names[i], d);
2911 video_enc->time_base.den = frame_rate;
2912 video_enc->time_base.num = frame_rate_base;
2913 if(codec && codec->supported_framerates){
2914 const AVRational *p= codec->supported_framerates;
2915 AVRational req= (AVRational){frame_rate, frame_rate_base};
2916 const AVRational *best=NULL;
2917 AVRational best_error= (AVRational){INT_MAX, 1};
2918 for(; p->den!=0; p++){
2919 AVRational error= av_sub_q(req, *p);
2920 if(error.num <0) error.num *= -1;
2921 if(av_cmp_q(error, best_error) < 0){
2926 video_enc->time_base.den= best->num;
2927 video_enc->time_base.num= best->den;
2930 video_enc->width = frame_width + frame_padright + frame_padleft;
2931 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2932 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2933 video_enc->pix_fmt = frame_pix_fmt;
2935 if(codec && codec->pix_fmts){
2936 const enum PixelFormat *p= codec->pix_fmts;
2938 if(*p == video_enc->pix_fmt)
2942 video_enc->pix_fmt = codec->pix_fmts[0];
2946 video_enc->gop_size = 0;
2947 if (video_qscale || same_quality) {
2948 video_enc->flags |= CODEC_FLAG_QSCALE;
2949 video_enc->global_quality=
2950 st->quality = FF_QP2LAMBDA * video_qscale;
2954 video_enc->intra_matrix = intra_matrix;
2956 video_enc->inter_matrix = inter_matrix;
2958 video_enc->qmin = video_qmin;
2959 video_enc->qmax = video_qmax;
2960 video_enc->lmin = video_lmin;
2961 video_enc->lmax = video_lmax;
2962 video_enc->rc_qsquish = video_qsquish;
2963 video_enc->mb_lmin = video_mb_lmin;
2964 video_enc->mb_lmax = video_mb_lmax;
2965 video_enc->max_qdiff = video_qdiff;
2966 video_enc->rc_eq = video_rc_eq;
2967 video_enc->workaround_bugs = workaround_bugs;
2968 video_enc->thread_count = thread_count;
2969 p= video_rc_override_string;
2972 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2974 fprintf(stderr, "error parsing rc_override\n");
2977 video_enc->rc_override=
2978 av_realloc(video_enc->rc_override,
2979 sizeof(RcOverride)*(i+1));
2980 video_enc->rc_override[i].start_frame= start;
2981 video_enc->rc_override[i].end_frame = end;
2983 video_enc->rc_override[i].qscale= q;
2984 video_enc->rc_override[i].quality_factor= 1.0;
2987 video_enc->rc_override[i].qscale= 0;
2988 video_enc->rc_override[i].quality_factor= -q/100.0;
2993 video_enc->rc_override_count=i;
2994 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2995 video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
2996 video_enc->me_threshold= me_threshold;
2997 video_enc->mb_threshold= mb_threshold;
2998 video_enc->intra_dc_precision= intra_dc_precision - 8;
2999 video_enc->strict_std_compliance = strict;
3000 video_enc->error_rate = error_rate;
3001 video_enc->scenechange_threshold= sc_threshold;
3002 video_enc->me_penalty_compensation= me_penalty_compensation;
3003 video_enc->frame_skip_threshold= frame_skip_threshold;
3004 video_enc->frame_skip_factor= frame_skip_factor;
3005 video_enc->frame_skip_exp= frame_skip_exp;
3008 video_enc->rtp_mode= 1;
3009 video_enc->rtp_payload_size= packet_size;
3013 video_enc->flags|= CODEC_FLAG_PSNR;
3015 video_enc->me_method = me_method;
3020 video_enc->flags |= CODEC_FLAG_PASS1;
3022 video_enc->flags |= CODEC_FLAG_PASS2;
3027 /* reset some key parameters */
3029 video_codec_id = CODEC_ID_NONE;
3030 video_stream_copy = 0;
3033 static void new_audio_stream(AVFormatContext *oc)
3036 AVCodecContext *audio_enc;
3039 st = av_new_stream(oc, oc->nb_streams);
3041 fprintf(stderr, "Could not alloc stream\n");
3045 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3046 audio_bitstream_filters= NULL;
3048 #if defined(HAVE_THREADS)
3050 avcodec_thread_init(st->codec, thread_count);
3053 audio_enc = st->codec;
3054 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3057 audio_enc->codec_tag= audio_codec_tag;
3059 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3060 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3061 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
3063 if (audio_stream_copy) {
3064 st->stream_copy = 1;
3065 audio_enc->channels = audio_channels;
3067 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3069 for(i=0; i<opt_name_count; i++){
3071 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3072 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3073 av_set_double(audio_enc, opt_names[i], d);
3076 if (audio_codec_id != CODEC_ID_NONE)
3077 codec_id = audio_codec_id;
3078 audio_enc->codec_id = codec_id;
3080 audio_enc->bit_rate = audio_bit_rate;
3081 if (audio_qscale > QSCALE_NONE) {
3082 audio_enc->flags |= CODEC_FLAG_QSCALE;
3083 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3085 audio_enc->strict_std_compliance = strict;
3086 audio_enc->thread_count = thread_count;
3087 /* For audio codecs other than AC3 or DTS we limit */
3088 /* the number of coded channels to stereo */
3089 if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3090 && codec_id != CODEC_ID_DTS) {
3091 audio_enc->channels = 2;
3093 audio_enc->channels = audio_channels;
3095 audio_enc->sample_rate = audio_sample_rate;
3096 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3097 if (audio_language) {
3098 pstrcpy(st->language, sizeof(st->language), audio_language);
3099 av_free(audio_language);
3100 audio_language = NULL;
3103 /* reset some key parameters */
3105 audio_codec_id = CODEC_ID_NONE;
3106 audio_stream_copy = 0;
3109 static void opt_new_subtitle_stream(void)
3111 AVFormatContext *oc;
3113 AVCodecContext *subtitle_enc;
3116 if (nb_output_files <= 0) {
3117 fprintf(stderr, "At least one output file must be specified\n");
3120 oc = output_files[nb_output_files - 1];
3122 st = av_new_stream(oc, oc->nb_streams);
3124 fprintf(stderr, "Could not alloc stream\n");
3128 subtitle_enc = st->codec;
3129 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3130 if (subtitle_stream_copy) {
3131 st->stream_copy = 1;
3133 for(i=0; i<opt_name_count; i++){
3135 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3136 if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3137 av_set_double(subtitle_enc, opt_names[i], d);
3139 subtitle_enc->codec_id = subtitle_codec_id;
3142 if (subtitle_language) {
3143 pstrcpy(st->language, sizeof(st->language), subtitle_language);
3144 av_free(subtitle_language);
3145 subtitle_language = NULL;
3148 subtitle_codec_id = CODEC_ID_NONE;
3149 subtitle_stream_copy = 0;
3152 static void opt_new_audio_stream(void)
3154 AVFormatContext *oc;
3155 if (nb_output_files <= 0) {
3156 fprintf(stderr, "At least one output file must be specified\n");
3159 oc = output_files[nb_output_files - 1];
3160 new_audio_stream(oc);
3163 static void opt_new_video_stream(void)
3165 AVFormatContext *oc;
3166 if (nb_output_files <= 0) {
3167 fprintf(stderr, "At least one output file must be specified\n");
3170 oc = output_files[nb_output_files - 1];
3171 new_video_stream(oc);
3174 static void opt_output_file(const char *filename)
3176 AVFormatContext *oc;
3177 int use_video, use_audio, input_has_video, input_has_audio, i;
3178 AVFormatParameters params, *ap = ¶ms;
3180 if (!strcmp(filename, "-"))
3183 oc = av_alloc_format_context();
3185 if (!file_oformat) {
3186 file_oformat = guess_format(NULL, filename, NULL);
3187 if (!file_oformat) {
3188 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3194 oc->oformat = file_oformat;
3195 pstrcpy(oc->filename, sizeof(oc->filename), filename);
3197 if (!strcmp(file_oformat->name, "ffm") &&
3198 strstart(filename, "http:", NULL)) {
3199 /* special case for files sent to ffserver: we get the stream
3200 parameters from ffserver */
3201 if (read_ffserver_streams(oc, filename) < 0) {
3202 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3206 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3207 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3209 /* disable if no corresponding type found and at least one
3211 if (nb_input_files > 0) {
3212 check_audio_video_inputs(&input_has_video, &input_has_audio);
3213 if (!input_has_video)
3215 if (!input_has_audio)
3219 /* manual disable */
3220 if (audio_disable) {
3223 if (video_disable) {
3228 new_video_stream(oc);
3232 new_audio_stream(oc);
3235 if (!oc->nb_streams) {
3236 fprintf(stderr, "No audio or video streams available\n");
3240 oc->timestamp = rec_timestamp;
3243 pstrcpy(oc->title, sizeof(oc->title), str_title);
3245 pstrcpy(oc->author, sizeof(oc->author), str_author);
3247 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3249 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3251 pstrcpy(oc->album, sizeof(oc->album), str_album);
3254 output_files[nb_output_files++] = oc;
3256 /* check filename in case of an image number is expected */
3257 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3258 if (!av_filename_number_test(oc->filename)) {
3259 print_error(oc->filename, AVERROR_NUMEXPECTED);
3264 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3265 /* test if it already exists to avoid loosing precious files */
3266 if (!file_overwrite &&
3267 (strchr(filename, ':') == NULL ||
3268 strstart(filename, "file:", NULL))) {
3269 if (url_exist(filename)) {
3272 if ( !using_stdin ) {
3273 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3276 if (toupper(c) != 'Y') {
3277 fprintf(stderr, "Not overwriting - exiting\n");
3282 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3289 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3290 fprintf(stderr, "Could not open '%s'\n", filename);
3295 memset(ap, 0, sizeof(*ap));
3296 ap->image_format = image_format;
3297 if (av_set_parameters(oc, ap) < 0) {
3298 fprintf(stderr, "%s: Invalid encoding parameters\n",
3303 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3304 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3305 oc->loop_output = loop_output;
3307 for(i=0; i<opt_name_count; i++){
3309 double d = av_get_double(avformat_opts, opt_names[i], &opt);
3310 if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3311 av_set_double(oc, opt_names[i], d);
3314 /* reset some options */
3315 file_oformat = NULL;
3316 file_iformat = NULL;
3317 image_format = NULL;
3320 /* prepare dummy protocols for grab */
3321 static void prepare_grab(void)
3323 int has_video, has_audio, i, j;
3324 AVFormatContext *oc;
3325 AVFormatContext *ic;
3326 AVFormatParameters vp1, *vp = &vp1;
3327 AVFormatParameters ap1, *ap = &ap1;
3329 /* see if audio/video inputs are needed */
3332 memset(ap, 0, sizeof(*ap));
3333 memset(vp, 0, sizeof(*vp));
3334 vp->time_base.num= 1;
3335 for(j=0;j<nb_output_files;j++) {
3336 oc = output_files[j];
3337 for(i=0;i<oc->nb_streams;i++) {
3338 AVCodecContext *enc = oc->streams[i]->codec;
3339 switch(enc->codec_type) {
3340 case CODEC_TYPE_AUDIO:
3341 if (enc->sample_rate > ap->sample_rate)
3342 ap->sample_rate = enc->sample_rate;
3343 if (enc->channels > ap->channels)
3344 ap->channels = enc->channels;
3347 case CODEC_TYPE_VIDEO:
3348 if (enc->width > vp->width)
3349 vp->width = enc->width;
3350 if (enc->height > vp->height)
3351 vp->height = enc->height;
3353 if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3354 vp->time_base = enc->time_base;
3355 vp->width += frame_leftBand + frame_rightBand;
3356 vp->width -= (frame_padleft + frame_padright);
3357 vp->height += frame_topBand + frame_bottomBand;
3358 vp->height -= (frame_padtop + frame_padbottom);
3368 if (has_video == 0 && has_audio == 0) {
3369 fprintf(stderr, "Output file must have at least one audio or video stream\n");
3374 AVInputFormat *fmt1;
3375 fmt1 = av_find_input_format(video_grab_format);
3376 vp->device = video_device;
3377 vp->channel = video_channel;
3378 vp->standard = video_standard;
3379 vp->pix_fmt = frame_pix_fmt;
3380 if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3381 fprintf(stderr, "Could not find video grab device\n");
3384 /* If not enough info to get the stream parameters, we decode the
3385 first frames to get it. */
3386 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3387 fprintf(stderr, "Could not find video grab parameters\n");
3390 /* by now video grab has one stream */
3391 ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3392 ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3393 input_files[nb_input_files] = ic;
3396 dump_format(ic, nb_input_files, "", 0);
3400 if (has_audio && audio_grab_format) {
3401 AVInputFormat *fmt1;
3402 fmt1 = av_find_input_format(audio_grab_format);
3403 ap->device = audio_device;
3404 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3405 fprintf(stderr, "Could not find audio grab device\n");
3408 input_files[nb_input_files] = ic;
3411 dump_format(ic, nb_input_files, "", 0);
3417 /* same option as mencoder */
3418 static void opt_pass(const char *pass_str)
3421 pass = atoi(pass_str);
3422 if (pass != 1 && pass != 2) {
3423 fprintf(stderr, "pass number can be only 1 or 2\n");
3429 #if defined(__MINGW32__) || defined(CONFIG_OS2)
3430 static int64_t getutime(void)
3432 return av_gettime();
3435 static int64_t getutime(void)
3437 struct rusage rusage;
3439 getrusage(RUSAGE_SELF, &rusage);
3440 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3444 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3445 extern int ffm_nopts;
3448 static void show_formats(void)
3450 AVInputFormat *ifmt;
3451 AVOutputFormat *ofmt;
3452 AVImageFormat *image_fmt;
3455 const char **pp, *last_name;
3457 printf("File formats:\n");
3462 const char *name=NULL;
3463 const char *long_name=NULL;
3465 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3466 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3467 strcmp(ofmt->name, last_name)>0){
3469 long_name= ofmt->long_name;
3473 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3474 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3475 strcmp(ifmt->name, last_name)>0){
3477 long_name= ifmt->long_name;
3480 if(name && strcmp(ifmt->name, name)==0)
3492 long_name ? long_name:" ");
3496 printf("Image formats (filename extensions, if any, follow):\n");
3497 for(image_fmt = first_image_format; image_fmt != NULL;
3498 image_fmt = image_fmt->next) {
3501 image_fmt->img_read ? "D":" ",
3502 image_fmt->img_write ? "E":" ",
3504 image_fmt->extensions ? image_fmt->extensions:" ");
3508 printf("Codecs:\n");
3514 const char *type_str;
3517 for(p = first_avcodec; p != NULL; p = p->next) {
3518 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3519 strcmp(p->name, last_name)>0){
3521 decode= encode= cap=0;
3523 if(p2 && strcmp(p->name, p2->name)==0){
3524 if(p->decode) decode=1;
3525 if(p->encode) encode=1;
3526 cap |= p->capabilities;
3531 last_name= p2->name;
3534 case CODEC_TYPE_VIDEO:
3537 case CODEC_TYPE_AUDIO:
3540 case CODEC_TYPE_SUBTITLE:
3549 decode ? "D": (/*p2->decoder ? "d":*/" "),
3552 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3553 cap & CODEC_CAP_DR1 ? "D":" ",
3554 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3556 /* if(p2->decoder && decode==0)
3557 printf(" use %s for decoding", p2->decoder->name);*/
3562 printf("Supported file protocols:\n");
3563 for(up = first_protocol; up != NULL; up = up->next)
3564 printf(" %s:", up->name);
3567 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3568 printf("Motion estimation methods:\n");
3572 if ((pp - motion_str + 1) == ME_ZERO)
3573 printf("(fastest)");
3574 else if ((pp - motion_str + 1) == ME_FULL)
3575 printf("(slowest)");
3576 else if ((pp - motion_str + 1) == ME_EPZS)
3577 printf("(default)");
3582 "Note, the names of encoders and decoders dont always match, so there are\n"
3583 "several cases where the above table shows encoder only or decoder only entries\n"
3584 "even though both encoding and decoding are supported for example, the h263\n"
3585 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3590 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3593 const char *p = str;
3600 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3607 static void opt_inter_matrix(const char *arg)
3609 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3610 parse_matrix_coeffs(inter_matrix, arg);
3613 static void opt_intra_matrix(const char *arg)
3615 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3616 parse_matrix_coeffs(intra_matrix, arg);
3619 static void opt_target(const char *arg)
3622 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3624 if(!strncmp(arg, "pal-", 4)) {
3627 } else if(!strncmp(arg, "ntsc-", 5)) {
3630 } else if(!strncmp(arg, "film-", 5)) {
3635 /* Calculate FR via float to avoid int overflow */
3636 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3639 } else if((fr == 29970) || (fr == 23976)) {
3642 /* Try to determine PAL/NTSC by peeking in the input files */
3643 if(nb_input_files) {
3645 for(j = 0; j < nb_input_files; j++) {
3646 for(i = 0; i < input_files[j]->nb_streams; i++) {
3647 AVCodecContext *c = input_files[j]->streams[i]->codec;
3648 if(c->codec_type != CODEC_TYPE_VIDEO)
3650 fr = c->time_base.den * 1000 / c->time_base.num;
3654 } else if((fr == 29970) || (fr == 23976)) {
3664 if(verbose && norm >= 0)
3665 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3669 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3670 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3671 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3675 if(!strcmp(arg, "vcd")) {
3677 opt_video_codec("mpeg1video");
3678 opt_audio_codec("mp2");
3681 opt_frame_size(norm ? "352x240" : "352x288");
3682 opt_frame_rate(frame_rates[norm]);
3683 opt_default("gop", norm ? "18" : "15");
3685 opt_default("b", "1150000");
3686 opt_default("maxrate", "1150000");
3687 opt_default("minrate", "1150000");
3688 opt_default("bufsize", "327680"); // 40*1024*8;
3690 audio_bit_rate = 224000;
3691 audio_sample_rate = 44100;
3693 opt_default("packetsize", "2324");
3694 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3696 /* We have to offset the PTS, so that it is consistent with the SCR.
3697 SCR starts at 36000, but the first two packs contain only padding
3698 and the first pack from the other stream, respectively, may also have
3699 been written before.
3700 So the real data starts at SCR 36000+3*1200. */
3701 mux_preload= (36000+3*1200) / 90000.0; //0.44
3702 } else if(!strcmp(arg, "svcd")) {
3704 opt_video_codec("mpeg2video");
3705 opt_audio_codec("mp2");
3708 opt_frame_size(norm ? "480x480" : "480x576");
3709 opt_frame_rate(frame_rates[norm]);
3710 opt_default("gop", norm ? "18" : "15");
3712 opt_default("b", "2040000");
3713 opt_default("maxrate", "2516000");
3714 opt_default("minrate", "0"); //1145000;
3715 opt_default("bufsize", "1835008"); //224*1024*8;
3716 opt_default("flags", "+SCAN_OFFSET");
3719 audio_bit_rate = 224000;
3720 audio_sample_rate = 44100;
3722 opt_default("packetsize", "2324");
3724 } else if(!strcmp(arg, "dvd")) {
3726 opt_video_codec("mpeg2video");
3727 opt_audio_codec("ac3");
3730 opt_frame_size(norm ? "720x480" : "720x576");
3731 opt_frame_rate(frame_rates[norm]);
3732 opt_default("gop", norm ? "18" : "15");