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 b_frames = 0;
134 static int do_deinterlace = 0;
135 static int workaround_bugs = FF_BUG_AUTODETECT;
136 static int packet_size = 0;
137 static int error_rate = 0;
138 static int strict = 0;
139 static int top_field_first = -1;
140 static int sc_threshold = 0;
141 static int me_threshold = 0;
142 static int mb_threshold = 0;
143 static int intra_dc_precision = 8;
144 static int me_penalty_compensation= 256;
145 static int frame_skip_threshold= 0;
146 static int frame_skip_factor= 0;
147 static int frame_skip_exp= 0;
148 static int loop_input = 0;
149 static int loop_output = AVFMT_NOOUTPUTLOOP;
150 static int qp_hist = 0;
152 static int intra_only = 0;
153 static int audio_sample_rate = 44100;
154 static int audio_bit_rate = 64000;
155 #define QSCALE_NONE -99999
156 static float audio_qscale = QSCALE_NONE;
157 static int audio_disable = 0;
158 static int audio_channels = 1;
159 static int audio_codec_id = CODEC_ID_NONE;
160 static int audio_codec_tag = 0;
161 static char *audio_language = NULL;
163 static int subtitle_codec_id = CODEC_ID_NONE;
164 static char *subtitle_language = NULL;
166 static int mux_rate= 0;
167 static int mux_packet_size= 0;
168 static float mux_preload= 0.5;
169 static float mux_max_delay= 0.7;
171 static int64_t recording_time = 0;
172 static int64_t start_time = 0;
173 static int64_t rec_timestamp = 0;
174 static int64_t input_ts_offset = 0;
175 static int file_overwrite = 0;
176 static char *str_title = NULL;
177 static char *str_author = NULL;
178 static char *str_copyright = NULL;
179 static char *str_comment = NULL;
180 static char *str_album = NULL;
181 static int do_benchmark = 0;
182 static int do_hex_dump = 0;
183 static int do_pkt_dump = 0;
184 static int do_psnr = 0;
185 static int do_vstats = 0;
186 static int do_pass = 0;
187 static char *pass_logfilename = NULL;
188 static int audio_stream_copy = 0;
189 static int video_stream_copy = 0;
190 static int subtitle_stream_copy = 0;
191 static int video_sync_method= 1;
192 static int audio_sync_method= 0;
193 static int copy_ts= 0;
194 static int opt_shortest = 0; //
195 static int video_global_header = 0;
197 static int rate_emu = 0;
200 static const char *video_grab_format = "bktr";
202 #ifdef CONFIG_VIDEO4LINUX2
203 static const char *video_grab_format = "video4linux2";
205 static const char *video_grab_format = "video4linux";
208 static char *video_device = NULL;
209 static char *grab_device = NULL;
210 static int video_channel = 0;
211 static char *video_standard = "ntsc";
213 static const char *audio_grab_format = "audio_device";
214 static char *audio_device = NULL;
215 static int audio_volume = 256;
217 static int using_stdin = 0;
218 static int using_vhook = 0;
219 static int verbose = 1;
220 static int thread_count= 1;
221 static int q_pressed = 0;
222 static int64_t video_size = 0;
223 static int64_t audio_size = 0;
224 static int64_t extra_size = 0;
225 static int nb_frames_dup = 0;
226 static int nb_frames_drop = 0;
227 static int input_sync;
228 static int limit_filesize = 0; //
230 static int pgmyuv_compatibility_hack=0;
231 static int dts_delta_threshold = 10;
233 static int sws_flags = SWS_BICUBIC;
235 const char **opt_names=NULL;
236 int opt_name_count=0;
237 AVCodecContext *avctx_opts;
238 AVFormatContext *avformat_opts;
240 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
241 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
242 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
244 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
246 struct AVInputStream;
248 typedef struct AVOutputStream {
249 int file_index; /* file index */
250 int index; /* stream index in the output file */
251 int source_index; /* AVInputStream index */
252 AVStream *st; /* stream in the output file */
253 int encoding_needed; /* true if encoding needed for this stream */
255 /* input pts and corresponding output pts
257 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
258 struct AVInputStream *sync_ist; /* input stream to sync against */
259 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
262 AVFrame pict_tmp; /* temporary image for resampling */
263 struct SwsContext *img_resample_ctx; /* for image resampling */
267 int topBand; /* cropping area sizes */
271 int padtop; /* padding area sizes */
278 ReSampleContext *resample; /* for audio resampling */
279 FifoBuffer fifo; /* for compression: one audio fifo per codec */
283 typedef struct AVInputStream {
287 int discard; /* true if stream data should be discarded */
288 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
289 int64_t sample_index; /* current sample */
291 int64_t start; /* time when read started */
292 unsigned long frame; /* current frame */
293 int64_t next_pts; /* synthetic pts for cases where pkt.pts
295 int64_t pts; /* current pts */
296 int is_start; /* is 1 at the start and after a discontinuity */
299 typedef struct AVInputFile {
300 int eof_reached; /* true if eof reached */
301 int ist_index; /* index of first stream in ist_table */
302 int buffer_size; /* current total buffer size */
303 int buffer_size_max; /* buffer size at which we consider we can stop
305 int nb_streams; /* nb streams we are aware of */
310 /* init terminal so that we can grab keys */
311 static struct termios oldtty;
313 static void term_exit(void)
315 tcsetattr (0, TCSANOW, &oldtty);
318 static volatile sig_atomic_t received_sigterm = 0;
321 sigterm_handler(int sig)
323 received_sigterm = sig;
327 static void term_init(void)
334 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
335 |INLCR|IGNCR|ICRNL|IXON);
336 tty.c_oflag |= OPOST;
337 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
338 tty.c_cflag &= ~(CSIZE|PARENB);
343 tcsetattr (0, TCSANOW, &tty);
345 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
346 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
347 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
349 register a function to be called at normal program termination
352 #ifdef CONFIG_BEOS_NETSERVER
353 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
357 /* read a key without blocking */
358 static int read_key(void)
362 #ifndef CONFIG_BEOS_NETSERVER
370 n = select(1, &rfds, NULL, NULL, &tv);
382 static int decode_interrupt_cb(void)
384 return q_pressed || (q_pressed = read_key() == 'q');
389 static volatile int received_sigterm = 0;
391 /* no interactive support */
392 static void term_exit(void)
396 static void term_init(void)
400 static int read_key(void)
407 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
412 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
415 /* copy stream format */
416 s->nb_streams = ic->nb_streams;
417 for(i=0;i<ic->nb_streams;i++) {
420 // FIXME: a more elegant solution is needed
421 st = av_mallocz(sizeof(AVStream));
422 memcpy(st, ic->streams[i], sizeof(AVStream));
423 st->codec = avcodec_alloc_context();
424 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
428 av_close_input_file(ic);
433 get_sync_ipts(const AVOutputStream *ost)
435 const AVInputStream *ist = ost->sync_ist;
436 return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
439 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
441 AVPacket new_pkt= *pkt;
442 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
443 &new_pkt.data, &new_pkt.size,
444 pkt->data, pkt->size,
445 pkt->flags & PKT_FLAG_KEY);
448 new_pkt.destruct= av_destruct_packet;
455 av_interleaved_write_frame(s, pkt);
458 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
460 static void do_audio_out(AVFormatContext *s,
463 unsigned char *buf, int size)
466 static uint8_t *audio_buf = NULL;
467 static uint8_t *audio_out = NULL;
468 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
470 int size_out, frame_bytes, ret;
471 AVCodecContext *enc= ost->st->codec;
473 /* SC: dynamic allocation of buffers */
475 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
477 audio_out = av_malloc(audio_out_size);
478 if (!audio_buf || !audio_out)
479 return; /* Should signal an error ! */
481 if(audio_sync_method){
482 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
483 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2);
484 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
485 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
487 //FIXME resample delay
488 if(fabs(delta) > 50){
491 byte_delta= FFMAX(byte_delta, -size);
495 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
500 static uint8_t *input_tmp= NULL;
501 input_tmp= av_realloc(input_tmp, byte_delta + size);
503 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
506 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
508 memset(input_tmp, 0, byte_delta);
509 memcpy(input_tmp + byte_delta, buf, size);
513 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
515 }else if(audio_sync_method>1){
516 int comp= clip(delta, -audio_sync_method, audio_sync_method);
517 assert(ost->audio_resample);
519 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
520 // 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));
521 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
525 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
526 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2); //FIXME wrong
528 if (ost->audio_resample) {
530 size_out = audio_resample(ost->resample,
531 (short *)buftmp, (short *)buf,
532 size / (ist->st->codec->channels * 2));
533 size_out = size_out * enc->channels * 2;
539 /* now encode as many frames as possible */
540 if (enc->frame_size > 1) {
541 /* output resampled raw samples */
542 fifo_write(&ost->fifo, buftmp, size_out,
545 frame_bytes = enc->frame_size * 2 * enc->channels;
547 while (fifo_read(&ost->fifo, audio_buf, frame_bytes,
548 &ost->fifo.rptr) == 0) {
550 av_init_packet(&pkt);
552 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
555 pkt.stream_index= ost->index;
558 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
559 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
560 pkt.flags |= PKT_FLAG_KEY;
561 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
563 ost->sync_opts += enc->frame_size;
567 av_init_packet(&pkt);
569 ost->sync_opts += size_out / (2 * enc->channels);
571 /* output a pcm frame */
572 /* XXX: change encoding codec API to avoid this ? */
573 switch(enc->codec->id) {
574 case CODEC_ID_PCM_S32LE:
575 case CODEC_ID_PCM_S32BE:
576 case CODEC_ID_PCM_U32LE:
577 case CODEC_ID_PCM_U32BE:
578 size_out = size_out << 1;
580 case CODEC_ID_PCM_S24LE:
581 case CODEC_ID_PCM_S24BE:
582 case CODEC_ID_PCM_U24LE:
583 case CODEC_ID_PCM_U24BE:
584 case CODEC_ID_PCM_S24DAUD:
585 size_out = size_out / 2 * 3;
587 case CODEC_ID_PCM_S16LE:
588 case CODEC_ID_PCM_S16BE:
589 case CODEC_ID_PCM_U16LE:
590 case CODEC_ID_PCM_U16BE:
593 size_out = size_out >> 1;
596 ret = avcodec_encode_audio(enc, audio_out, size_out,
599 pkt.stream_index= ost->index;
602 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
603 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
604 pkt.flags |= PKT_FLAG_KEY;
605 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
609 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
613 AVPicture picture_tmp;
616 dec = ist->st->codec;
618 /* deinterlace : must be done before any resize */
619 if (do_deinterlace || using_vhook) {
622 /* create temporary picture */
623 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
624 buf = av_malloc(size);
628 picture2 = &picture_tmp;
629 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
632 if(avpicture_deinterlace(picture2, picture,
633 dec->pix_fmt, dec->width, dec->height) < 0) {
634 /* if error, do not deinterlace */
640 img_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
646 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
648 if (picture != picture2)
649 *picture = *picture2;
653 /* we begin to correct av delay at this threshold */
654 #define AV_DELAY_MAX 0.100
656 static void do_subtitle_out(AVFormatContext *s,
662 static uint8_t *subtitle_out = NULL;
663 int subtitle_out_max_size = 65536;
664 int subtitle_out_size, nb, i;
668 if (pts == AV_NOPTS_VALUE) {
669 fprintf(stderr, "Subtitle packets must have a pts\n");
673 enc = ost->st->codec;
676 subtitle_out = av_malloc(subtitle_out_max_size);
679 /* Note: DVB subtitle need one packet to draw them and one other
680 packet to clear them */
681 /* XXX: signal it in the codec context ? */
682 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
687 for(i = 0; i < nb; i++) {
688 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
689 subtitle_out_max_size, sub);
691 av_init_packet(&pkt);
692 pkt.stream_index = ost->index;
693 pkt.data = subtitle_out;
694 pkt.size = subtitle_out_size;
695 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);
696 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
697 /* XXX: the pts correction is handled here. Maybe handling
698 it in the codec would be better */
700 pkt.pts += 90 * sub->start_display_time;
702 pkt.pts += 90 * sub->end_display_time;
704 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
708 static int bit_buffer_size= 1024*256;
709 static uint8_t *bit_buffer= NULL;
711 static void do_video_out(AVFormatContext *s,
717 int nb_frames, i, ret;
718 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
719 AVFrame picture_crop_temp, picture_pad_temp;
720 uint8_t *buf = NULL, *buf1 = NULL;
721 AVCodecContext *enc, *dec;
723 avcodec_get_frame_defaults(&picture_crop_temp);
724 avcodec_get_frame_defaults(&picture_pad_temp);
726 enc = ost->st->codec;
727 dec = ist->st->codec;
729 /* by default, we output a single frame */
734 if(video_sync_method){
736 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
737 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
740 else if (vdelta > 1.1)
741 nb_frames = lrintf(vdelta);
742 //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);
746 fprintf(stderr, "*** drop!\n");
747 }else if (nb_frames > 1) {
748 nb_frames_dup += nb_frames;
750 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
753 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
755 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
759 if (ost->video_crop) {
760 if (img_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
761 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
764 formatted_picture = &picture_crop_temp;
766 formatted_picture = in_picture;
769 final_picture = formatted_picture;
770 padding_src = formatted_picture;
771 resampling_dst = &ost->pict_tmp;
772 if (ost->video_pad) {
773 final_picture = &ost->pict_tmp;
774 if (ost->video_resample) {
775 if (img_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
776 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
779 resampling_dst = &picture_pad_temp;
783 if (ost->video_resample) {
785 final_picture = &ost->pict_tmp;
786 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
787 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
790 if (ost->video_pad) {
791 img_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
792 enc->height, enc->width, enc->pix_fmt,
793 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
796 /* duplicates frame if needed */
797 for(i=0;i<nb_frames;i++) {
799 av_init_packet(&pkt);
800 pkt.stream_index= ost->index;
802 if (s->oformat->flags & AVFMT_RAWPICTURE) {
803 /* raw pictures are written as AVPicture structure to
804 avoid any copies. We support temorarily the older
806 AVFrame* old_frame = enc->coded_frame;
807 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
808 pkt.data= (uint8_t *)final_picture;
809 pkt.size= sizeof(AVPicture);
810 if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
811 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
812 if(dec->coded_frame && dec->coded_frame->key_frame)
813 pkt.flags |= PKT_FLAG_KEY;
815 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
816 enc->coded_frame = old_frame;
820 big_picture= *final_picture;
821 /* better than nothing: use input picture interlaced
823 big_picture.interlaced_frame = in_picture->interlaced_frame;
824 if(avctx_opts->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
825 if(top_field_first == -1)
826 big_picture.top_field_first = in_picture->top_field_first;
828 big_picture.top_field_first = top_field_first;
831 /* handles sameq here. This is not correct because it may
832 not be a global option */
834 big_picture.quality = ist->st->quality;
836 big_picture.quality = ost->st->quality;
838 big_picture.pict_type = 0;
839 // big_picture.pts = AV_NOPTS_VALUE;
840 big_picture.pts= ost->sync_opts;
841 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
842 //av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
843 ret = avcodec_encode_video(enc,
844 bit_buffer, bit_buffer_size,
846 //enc->frame_number = enc->real_pict_num;
848 pkt.data= bit_buffer;
850 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
851 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
852 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n",
853 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
854 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
856 if(enc->coded_frame && enc->coded_frame->key_frame)
857 pkt.flags |= PKT_FLAG_KEY;
858 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
860 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
861 // enc->frame_number-1, enc->real_pict_num, ret,
863 /* if two pass, output log */
864 if (ost->logfile && enc->stats_out) {
865 fprintf(ost->logfile, "%s", enc->stats_out);
877 static double psnr(double d){
878 if(d==0) return INFINITY;
879 return -10.0*log(d)/log(10.0);
882 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
885 static FILE *fvstats=NULL;
892 double ti1, bitrate, avg_bitrate;
896 today = localtime(&today2);
897 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
900 fvstats = fopen(filename,"w");
908 enc = ost->st->codec;
909 if (enc->codec_type == CODEC_TYPE_VIDEO) {
910 frame_number = ost->frame_number;
911 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
912 if (enc->flags&CODEC_FLAG_PSNR)
913 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
915 fprintf(fvstats,"f_size= %6d ", frame_size);
916 /* compute pts value */
917 ti1 = ost->sync_opts * av_q2d(enc->time_base);
921 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
922 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
923 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
924 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
925 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
929 static void print_report(AVFormatContext **output_files,
930 AVOutputStream **ost_table, int nb_ostreams,
935 AVFormatContext *oc, *os;
938 int frame_number, vid, i;
939 double bitrate, ti1, pts;
940 static int64_t last_time = -1;
941 static int qp_histogram[52];
943 if (!is_last_report) {
945 /* display the report every 0.5 seconds */
946 cur_time = av_gettime();
947 if (last_time == -1) {
948 last_time = cur_time;
951 if ((cur_time - last_time) < 500000)
953 last_time = cur_time;
957 oc = output_files[0];
959 total_size = url_ftell(&oc->pb);
964 for(i=0;i<nb_ostreams;i++) {
966 os = output_files[ost->file_index];
967 enc = ost->st->codec;
968 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
969 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
970 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
972 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
973 frame_number = ost->frame_number;
974 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%3.1f ",
975 frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
977 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
978 if(qp_hist && enc->coded_frame){
980 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
981 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
984 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
986 if (enc->flags&CODEC_FLAG_PSNR){
988 double error, error_sum=0;
989 double scale, scale_sum=0;
990 char type[3]= {'Y','U','V'};
991 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
994 error= enc->error[j];
995 scale= enc->width*enc->height*255.0*255.0*frame_number;
997 error= enc->coded_frame->error[j];
998 scale= enc->width*enc->height*255.0*255.0;
1003 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1005 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1009 /* compute min output value */
1010 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1011 if ((pts < ti1) && (pts > 0))
1017 if (verbose || is_last_report) {
1018 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1020 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1021 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1022 (double)total_size / 1024, ti1, bitrate);
1025 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1026 nb_frames_dup, nb_frames_drop);
1029 fprintf(stderr, "%s \r", buf);
1034 if (is_last_report && verbose >= 0){
1035 int64_t raw= audio_size + video_size + extra_size;
1036 fprintf(stderr, "\n");
1037 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1041 100.0*(total_size - raw)/raw
1046 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1047 static int output_packet(AVInputStream *ist, int ist_index,
1048 AVOutputStream **ost_table, int nb_ostreams,
1049 const AVPacket *pkt)
1051 AVFormatContext *os;
1052 AVOutputStream *ost;
1056 int data_size, got_picture;
1058 void *buffer_to_free;
1059 static unsigned int samples_size= 0;
1060 static short *samples= NULL;
1061 AVSubtitle subtitle, *subtitle_to_free;
1065 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1066 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1067 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1069 // assert(ist->pts == ist->next_pts);
1083 /* decode the packet if needed */
1084 data_buf = NULL; /* fail safe */
1086 subtitle_to_free = NULL;
1087 if (ist->decoding_needed) {
1088 switch(ist->st->codec->codec_type) {
1089 case CODEC_TYPE_AUDIO:{
1091 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1092 /* XXX: could avoid copy if PCM 16 bits with same
1093 endianness as CPU */
1094 ret = avcodec_decode_audio(ist->st->codec, samples, &data_size,
1100 /* Some bug in mpeg audio decoder gives */
1101 /* data_size < 0, it seems they are overflows */
1102 if (data_size <= 0) {
1103 /* no audio frame */
1106 data_buf = (uint8_t *)samples;
1107 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1108 (ist->st->codec->sample_rate * ist->st->codec->channels);
1110 case CODEC_TYPE_VIDEO:
1111 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1112 /* XXX: allocate picture correctly */
1113 avcodec_get_frame_defaults(&picture);
1115 ret = avcodec_decode_video(ist->st->codec,
1116 &picture, &got_picture, ptr, len);
1117 ist->st->quality= picture.quality;
1121 /* no picture yet */
1122 goto discard_packet;
1124 if (ist->st->codec->time_base.num != 0) {
1125 ist->next_pts += ((int64_t)AV_TIME_BASE *
1126 ist->st->codec->time_base.num) /
1127 ist->st->codec->time_base.den;
1131 case CODEC_TYPE_SUBTITLE:
1132 ret = avcodec_decode_subtitle(ist->st->codec,
1133 &subtitle, &got_subtitle, ptr, len);
1136 if (!got_subtitle) {
1137 goto discard_packet;
1139 subtitle_to_free = &subtitle;
1146 switch(ist->st->codec->codec_type) {
1147 case CODEC_TYPE_AUDIO:
1148 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1149 (ist->st->codec->sample_rate * ist->st->codec->channels);
1151 case CODEC_TYPE_VIDEO:
1152 if (ist->st->codec->time_base.num != 0) {
1153 ist->next_pts += ((int64_t)AV_TIME_BASE *
1154 ist->st->codec->time_base.num) /
1155 ist->st->codec->time_base.den;
1165 buffer_to_free = NULL;
1166 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1167 pre_process_video_frame(ist, (AVPicture *)&picture,
1171 // preprocess audio (volume)
1172 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1173 if (audio_volume != 256) {
1176 for(i=0;i<(data_size / sizeof(short));i++) {
1177 int v = ((*volp) * audio_volume + 128) >> 8;
1178 if (v < -32768) v = -32768;
1179 if (v > 32767) v = 32767;
1185 /* frame rate emulation */
1186 if (ist->st->codec->rate_emu) {
1187 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1188 int64_t now = av_gettime() - ist->start;
1196 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1197 is the one of the next displayed one */
1198 /* XXX: add mpeg4 too ? */
1199 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1200 if (ist->st->codec->pict_type != B_TYPE) {
1202 tmp = ist->last_ip_pts;
1203 ist->last_ip_pts = ist->frac_pts.val;
1204 ist->frac_pts.val = tmp;
1208 /* if output time reached then transcode raw format,
1209 encode packets and output them */
1210 if (start_time == 0 || ist->pts >= start_time)
1211 for(i=0;i<nb_ostreams;i++) {
1215 if (ost->source_index == ist_index) {
1216 os = output_files[ost->file_index];
1219 printf("%d: got pts=%0.3f %0.3f\n", i,
1220 (double)pkt->pts / AV_TIME_BASE,
1221 ((double)ist->pts / AV_TIME_BASE) -
1222 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1224 /* set the input output pts pairs */
1225 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1227 if (ost->encoding_needed) {
1228 switch(ost->st->codec->codec_type) {
1229 case CODEC_TYPE_AUDIO:
1230 do_audio_out(os, ost, ist, data_buf, data_size);
1232 case CODEC_TYPE_VIDEO:
1233 do_video_out(os, ost, ist, &picture, &frame_size);
1234 video_size += frame_size;
1235 if (do_vstats && frame_size)
1236 do_video_stats(os, ost, frame_size);
1238 case CODEC_TYPE_SUBTITLE:
1239 do_subtitle_out(os, ost, ist, &subtitle,
1246 AVFrame avframe; //FIXME/XXX remove this
1248 av_init_packet(&opkt);
1250 /* no reencoding needed : output the packet directly */
1251 /* force the input stream PTS */
1253 avcodec_get_frame_defaults(&avframe);
1254 ost->st->codec->coded_frame= &avframe;
1255 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1257 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1258 audio_size += data_size;
1259 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1260 video_size += data_size;
1264 opkt.stream_index= ost->index;
1265 if(pkt->pts != AV_NOPTS_VALUE)
1266 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);
1268 opkt.pts= AV_NOPTS_VALUE;
1272 if (pkt->dts == AV_NOPTS_VALUE)
1273 dts = ist->next_pts;
1275 dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1276 opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
1278 opkt.flags= pkt->flags;
1280 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1281 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1282 opkt.destruct= av_destruct_packet;
1284 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1285 ost->st->codec->frame_number++;
1286 ost->frame_number++;
1287 av_free_packet(&opkt);
1291 av_free(buffer_to_free);
1292 /* XXX: allocate the subtitles in the codec ? */
1293 if (subtitle_to_free) {
1294 if (subtitle_to_free->rects != NULL) {
1295 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1296 av_free(subtitle_to_free->rects[i].bitmap);
1297 av_free(subtitle_to_free->rects[i].rgba_palette);
1299 av_freep(&subtitle_to_free->rects);
1301 subtitle_to_free->num_rects = 0;
1302 subtitle_to_free = NULL;
1309 for(i=0;i<nb_ostreams;i++) {
1311 if (ost->source_index == ist_index) {
1312 AVCodecContext *enc= ost->st->codec;
1313 os = output_files[ost->file_index];
1315 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1317 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1320 if (ost->encoding_needed) {
1324 av_init_packet(&pkt);
1325 pkt.stream_index= ost->index;
1327 switch(ost->st->codec->codec_type) {
1328 case CODEC_TYPE_AUDIO:
1329 fifo_bytes = fifo_size(&ost->fifo, NULL);
1331 /* encode any samples remaining in fifo */
1332 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1333 int fs_tmp = enc->frame_size;
1334 enc->frame_size = fifo_bytes / (2 * enc->channels);
1335 if(fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes,
1336 &ost->fifo.rptr) == 0) {
1337 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1339 enc->frame_size = fs_tmp;
1342 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1345 pkt.flags |= PKT_FLAG_KEY;
1347 case CODEC_TYPE_VIDEO:
1348 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1350 if(enc->coded_frame && enc->coded_frame->key_frame)
1351 pkt.flags |= PKT_FLAG_KEY;
1352 if (ost->logfile && enc->stats_out) {
1353 fprintf(ost->logfile, "%s", enc->stats_out);
1362 pkt.data= bit_buffer;
1364 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1365 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1366 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1380 * The following code is the main loop of the file converter
1382 static int av_encode(AVFormatContext **output_files,
1383 int nb_output_files,
1384 AVFormatContext **input_files,
1386 AVStreamMap *stream_maps, int nb_stream_maps)
1388 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1389 AVFormatContext *is, *os;
1390 AVCodecContext *codec, *icodec;
1391 AVOutputStream *ost, **ost_table = NULL;
1392 AVInputStream *ist, **ist_table = NULL;
1393 AVInputFile *file_table;
1394 AVFormatContext *stream_no_data;
1397 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1401 /* input stream init */
1403 for(i=0;i<nb_input_files;i++) {
1404 is = input_files[i];
1405 file_table[i].ist_index = j;
1406 file_table[i].nb_streams = is->nb_streams;
1407 j += is->nb_streams;
1411 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1415 for(i=0;i<nb_istreams;i++) {
1416 ist = av_mallocz(sizeof(AVInputStream));
1422 for(i=0;i<nb_input_files;i++) {
1423 is = input_files[i];
1424 for(k=0;k<is->nb_streams;k++) {
1425 ist = ist_table[j++];
1426 ist->st = is->streams[k];
1427 ist->file_index = i;
1429 ist->discard = 1; /* the stream is discarded by default
1432 if (ist->st->codec->rate_emu) {
1433 ist->start = av_gettime();
1439 /* output stream init */
1441 for(i=0;i<nb_output_files;i++) {
1442 os = output_files[i];
1443 nb_ostreams += os->nb_streams;
1445 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1446 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1450 /* Sanity check the mapping args -- do the input files & streams exist? */
1451 for(i=0;i<nb_stream_maps;i++) {
1452 int fi = stream_maps[i].file_index;
1453 int si = stream_maps[i].stream_index;
1455 if (fi < 0 || fi > nb_input_files - 1 ||
1456 si < 0 || si > file_table[fi].nb_streams - 1) {
1457 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1460 fi = stream_maps[i].sync_file_index;
1461 si = stream_maps[i].sync_stream_index;
1462 if (fi < 0 || fi > nb_input_files - 1 ||
1463 si < 0 || si > file_table[fi].nb_streams - 1) {
1464 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1469 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1472 for(i=0;i<nb_ostreams;i++) {
1473 ost = av_mallocz(sizeof(AVOutputStream));
1480 for(k=0;k<nb_output_files;k++) {
1481 os = output_files[k];
1482 for(i=0;i<os->nb_streams;i++) {
1484 ost = ost_table[n++];
1485 ost->file_index = k;
1487 ost->st = os->streams[i];
1488 if (nb_stream_maps > 0) {
1489 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1490 stream_maps[n-1].stream_index;
1492 /* Sanity check that the stream types match */
1493 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1494 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1495 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1496 ost->file_index, ost->index);
1501 /* get corresponding input stream index : we select the first one with the right type */
1503 for(j=0;j<nb_istreams;j++) {
1506 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1507 ost->source_index = j;
1514 /* try again and reuse existing stream */
1515 for(j=0;j<nb_istreams;j++) {
1517 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1518 ost->source_index = j;
1523 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1524 ost->file_index, ost->index);
1529 ist = ist_table[ost->source_index];
1531 ost->sync_ist = (nb_stream_maps > 0) ?
1532 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1533 stream_maps[n-1].sync_stream_index] : ist;
1537 /* for each output stream, we compute the right encoding parameters */
1538 for(i=0;i<nb_ostreams;i++) {
1540 ist = ist_table[ost->source_index];
1542 codec = ost->st->codec;
1543 icodec = ist->st->codec;
1545 if (ost->st->stream_copy) {
1546 /* if stream_copy is selected, no need to decode or encode */
1547 codec->codec_id = icodec->codec_id;
1548 codec->codec_type = icodec->codec_type;
1549 if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1550 codec->bit_rate = icodec->bit_rate;
1551 codec->extradata= icodec->extradata;
1552 codec->extradata_size= icodec->extradata_size;
1553 codec->time_base = icodec->time_base;
1554 switch(codec->codec_type) {
1555 case CODEC_TYPE_AUDIO:
1556 codec->sample_rate = icodec->sample_rate;
1557 codec->channels = icodec->channels;
1558 codec->frame_size = icodec->frame_size;
1559 codec->block_align= icodec->block_align;
1561 case CODEC_TYPE_VIDEO:
1562 codec->pix_fmt = icodec->pix_fmt;
1563 codec->width = icodec->width;
1564 codec->height = icodec->height;
1565 codec->has_b_frames = icodec->has_b_frames;
1567 case CODEC_TYPE_SUBTITLE:
1573 switch(codec->codec_type) {
1574 case CODEC_TYPE_AUDIO:
1575 if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1578 if (codec->channels == icodec->channels &&
1579 codec->sample_rate == icodec->sample_rate) {
1580 ost->audio_resample = 0;
1582 if (codec->channels != icodec->channels &&
1583 (icodec->codec_id == CODEC_ID_AC3 ||
1584 icodec->codec_id == CODEC_ID_DTS)) {
1585 /* Special case for 5:1 AC3 and DTS input */
1586 /* and mono or stereo output */
1587 /* Request specific number of channels */
1588 icodec->channels = codec->channels;
1589 if (codec->sample_rate == icodec->sample_rate)
1590 ost->audio_resample = 0;
1592 ost->audio_resample = 1;
1595 ost->audio_resample = 1;
1598 if(audio_sync_method>1)
1599 ost->audio_resample = 1;
1601 if(ost->audio_resample){
1602 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1603 codec->sample_rate, icodec->sample_rate);
1605 printf("Can't resample. Aborting.\n");
1609 ist->decoding_needed = 1;
1610 ost->encoding_needed = 1;
1612 case CODEC_TYPE_VIDEO:
1613 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1614 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1615 ost->video_resample = ((codec->width != icodec->width -
1616 (frame_leftBand + frame_rightBand) +
1617 (frame_padleft + frame_padright)) ||
1618 (codec->height != icodec->height -
1619 (frame_topBand + frame_bottomBand) +
1620 (frame_padtop + frame_padbottom)) ||
1621 (codec->pix_fmt != icodec->pix_fmt));
1622 if (ost->video_crop) {
1623 ost->topBand = frame_topBand;
1624 ost->leftBand = frame_leftBand;
1626 if (ost->video_pad) {
1627 ost->padtop = frame_padtop;
1628 ost->padleft = frame_padleft;
1629 ost->padbottom = frame_padbottom;
1630 ost->padright = frame_padright;
1631 if (!ost->video_resample) {
1632 avcodec_get_frame_defaults(&ost->pict_tmp);
1633 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1634 codec->width, codec->height ) )
1638 if (ost->video_resample) {
1639 avcodec_get_frame_defaults(&ost->pict_tmp);
1640 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1641 codec->width, codec->height ) )
1644 ost->img_resample_ctx = sws_getContext(
1645 icodec->width - (frame_leftBand + frame_rightBand),
1646 icodec->height - (frame_topBand + frame_bottomBand),
1648 codec->width - (frame_padleft + frame_padright),
1649 codec->height - (frame_padtop + frame_padbottom),
1651 sws_flags, NULL, NULL, NULL);
1652 if (ost->img_resample_ctx == NULL) {
1653 fprintf(stderr, "Cannot get resampling context\n");
1656 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1658 ost->encoding_needed = 1;
1659 ist->decoding_needed = 1;
1661 case CODEC_TYPE_SUBTITLE:
1662 ost->encoding_needed = 1;
1663 ist->decoding_needed = 1;
1670 if (ost->encoding_needed &&
1671 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1672 char logfilename[1024];
1677 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1679 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1680 if (codec->flags & CODEC_FLAG_PASS1) {
1681 f = fopen(logfilename, "w");
1683 perror(logfilename);
1688 /* read the log file */
1689 f = fopen(logfilename, "r");
1691 perror(logfilename);
1694 fseek(f, 0, SEEK_END);
1696 fseek(f, 0, SEEK_SET);
1697 logbuffer = av_malloc(size + 1);
1699 fprintf(stderr, "Could not allocate log buffer\n");
1702 size = fread(logbuffer, 1, size, f);
1704 logbuffer[size] = '\0';
1705 codec->stats_in = logbuffer;
1709 if(codec->codec_type == CODEC_TYPE_VIDEO){
1710 int size= codec->width * codec->height;
1711 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1716 bit_buffer = av_malloc(bit_buffer_size);
1720 /* dump the file output parameters - cannot be done before in case
1722 for(i=0;i<nb_output_files;i++) {
1723 dump_format(output_files[i], i, output_files[i]->filename, 1);
1726 /* dump the stream mapping */
1728 fprintf(stderr, "Stream mapping:\n");
1729 for(i=0;i<nb_ostreams;i++) {
1731 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1732 ist_table[ost->source_index]->file_index,
1733 ist_table[ost->source_index]->index,
1736 if (ost->sync_ist != ist_table[ost->source_index])
1737 fprintf(stderr, " [sync #%d.%d]",
1738 ost->sync_ist->file_index,
1739 ost->sync_ist->index);
1740 fprintf(stderr, "\n");
1744 /* open each encoder */
1745 for(i=0;i<nb_ostreams;i++) {
1747 if (ost->encoding_needed) {
1749 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1751 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1752 ost->file_index, ost->index);
1755 if (avcodec_open(ost->st->codec, codec) < 0) {
1756 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1757 ost->file_index, ost->index);
1760 extra_size += ost->st->codec->extradata_size;
1764 /* open each decoder */
1765 for(i=0;i<nb_istreams;i++) {
1767 if (ist->decoding_needed) {
1769 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1771 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1772 ist->st->codec->codec_id, ist->file_index, ist->index);
1775 if (avcodec_open(ist->st->codec, codec) < 0) {
1776 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1777 ist->file_index, ist->index);
1780 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1781 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1786 for(i=0;i<nb_istreams;i++) {
1788 is = input_files[ist->file_index];
1790 ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1791 if(ist->st->start_time == AV_NOPTS_VALUE)
1793 if(input_files_ts_offset[ist->file_index])
1794 ist->next_pts= AV_NOPTS_VALUE;
1798 /* compute buffer size max (should use a complete heuristic) */
1799 for(i=0;i<nb_input_files;i++) {
1800 file_table[i].buffer_size_max = 2048;
1803 /* set meta data information from input file if required */
1804 for (i=0;i<nb_meta_data_maps;i++) {
1805 AVFormatContext *out_file;
1806 AVFormatContext *in_file;
1808 int out_file_index = meta_data_maps[i].out_file;
1809 int in_file_index = meta_data_maps[i].in_file;
1810 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1811 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1815 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1816 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1821 out_file = output_files[out_file_index];
1822 in_file = input_files[in_file_index];
1824 strcpy(out_file->title, in_file->title);
1825 strcpy(out_file->author, in_file->author);
1826 strcpy(out_file->copyright, in_file->copyright);
1827 strcpy(out_file->comment, in_file->comment);
1828 strcpy(out_file->album, in_file->album);
1829 out_file->year = in_file->year;
1830 out_file->track = in_file->track;
1831 strcpy(out_file->genre, in_file->genre);
1834 /* open files and write file headers */
1835 for(i=0;i<nb_output_files;i++) {
1836 os = output_files[i];
1837 if (av_write_header(os) < 0) {
1838 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1845 if ( !using_stdin && verbose >= 0) {
1846 fprintf(stderr, "Press [q] to stop encoding\n");
1847 url_set_interrupt_cb(decode_interrupt_cb);
1855 for(; received_sigterm == 0;) {
1856 int file_index, ist_index;
1864 /* if 'q' pressed, exits */
1868 /* read_key() returns 0 on EOF */
1874 /* select the stream that we must read now by looking at the
1875 smallest output pts */
1877 for(i=0;i<nb_ostreams;i++) {
1880 os = output_files[ost->file_index];
1881 ist = ist_table[ost->source_index];
1882 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1883 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1885 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1886 ipts = (double)ist->pts;
1887 if (!file_table[ist->file_index].eof_reached){
1888 if(ipts < ipts_min) {
1890 if(input_sync ) file_index = ist->file_index;
1892 if(opts < opts_min) {
1894 if(!input_sync) file_index = ist->file_index;
1897 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1902 /* if none, if is finished */
1903 if (file_index < 0) {
1907 /* finish if recording time exhausted */
1908 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1911 /* finish if limit size exhausted */
1912 if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1915 /* read a frame from it and output it in the fifo */
1916 is = input_files[file_index];
1917 if (av_read_frame(is, &pkt) < 0) {
1918 file_table[file_index].eof_reached = 1;
1919 if (opt_shortest) break; else continue; //
1923 stream_no_data = is;
1928 av_pkt_dump(stdout, &pkt, do_hex_dump);
1930 /* the following test is needed in case new streams appear
1931 dynamically in stream : we ignore them */
1932 if (pkt.stream_index >= file_table[file_index].nb_streams)
1933 goto discard_packet;
1934 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1935 ist = ist_table[ist_index];
1937 goto discard_packet;
1939 // 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);
1940 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1941 int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1942 if(ABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1943 input_files_ts_offset[ist->file_index]-= delta;
1945 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1946 for(i=0; i<file_table[file_index].nb_streams; i++){
1947 int index= file_table[file_index].ist_index + i;
1948 ist_table[index]->next_pts += delta;
1949 ist_table[index]->is_start=1;
1954 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1955 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1958 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1959 ist->file_index, ist->index);
1961 av_free_packet(&pkt);
1966 av_free_packet(&pkt);
1968 /* dump report by using the output first video and audio streams */
1969 print_report(output_files, ost_table, nb_ostreams, 0);
1972 /* at the end of stream, we must flush the decoder buffers */
1973 for(i=0;i<nb_istreams;i++) {
1975 if (ist->decoding_needed) {
1976 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1982 /* write the trailer if needed and close file */
1983 for(i=0;i<nb_output_files;i++) {
1984 os = output_files[i];
1985 av_write_trailer(os);
1988 /* dump report by using the first video and audio streams */
1989 print_report(output_files, ost_table, nb_ostreams, 1);
1991 /* close each encoder */
1992 for(i=0;i<nb_ostreams;i++) {
1994 if (ost->encoding_needed) {
1995 av_freep(&ost->st->codec->stats_in);
1996 avcodec_close(ost->st->codec);
2000 /* close each decoder */
2001 for(i=0;i<nb_istreams;i++) {
2003 if (ist->decoding_needed) {
2004 avcodec_close(ist->st->codec);
2012 av_freep(&bit_buffer);
2013 av_free(file_table);
2016 for(i=0;i<nb_istreams;i++) {
2023 for(i=0;i<nb_ostreams;i++) {
2027 fclose(ost->logfile);
2028 ost->logfile = NULL;
2030 fifo_free(&ost->fifo); /* works even if fifo is not
2031 initialized but set to zero */
2032 av_free(ost->pict_tmp.data[0]);
2033 if (ost->video_resample)
2034 sws_freeContext(ost->img_resample_ctx);
2035 if (ost->audio_resample)
2036 audio_resample_close(ost->resample);
2049 int file_read(const char *filename)
2052 unsigned char buffer[1024];
2055 if (url_open(&h, filename, O_RDONLY) < 0) {
2056 printf("could not open '%s'\n", filename);
2060 len = url_read(h, buffer, sizeof(buffer));
2063 for(i=0;i<len;i++) putchar(buffer[i]);
2070 static void opt_image_format(const char *arg)
2074 for(f = first_image_format; f != NULL; f = f->next) {
2075 if (!strcmp(arg, f->name))
2079 fprintf(stderr, "Unknown image format: '%s'\n", arg);
2085 static void opt_format(const char *arg)
2087 /* compatibility stuff for pgmyuv */
2088 if (!strcmp(arg, "pgmyuv")) {
2089 pgmyuv_compatibility_hack=1;
2090 // opt_image_format(arg);
2094 file_iformat = av_find_input_format(arg);
2095 file_oformat = guess_format(arg, NULL, NULL);
2096 if (!file_iformat && !file_oformat) {
2097 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2102 static void opt_video_rc_eq(char *arg)
2107 static void opt_video_rc_override_string(char *arg)
2109 video_rc_override_string = arg;
2113 static void opt_workaround_bugs(const char *arg)
2115 workaround_bugs = atoi(arg);
2118 static void opt_me_threshold(const char *arg)
2120 me_threshold = atoi(arg);
2123 static void opt_mb_threshold(const char *arg)
2125 mb_threshold = atoi(arg);
2128 static void opt_verbose(const char *arg)
2130 verbose = atoi(arg);
2131 av_log_set_level(atoi(arg));
2134 static void opt_frame_rate(const char *arg)
2136 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2137 fprintf(stderr, "Incorrect frame rate\n");
2142 static void opt_frame_crop_top(const char *arg)
2144 frame_topBand = atoi(arg);
2145 if (frame_topBand < 0) {
2146 fprintf(stderr, "Incorrect top crop size\n");
2149 if ((frame_topBand % 2) != 0) {
2150 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2153 if ((frame_topBand) >= frame_height){
2154 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2157 frame_height -= frame_topBand;
2160 static void opt_frame_crop_bottom(const char *arg)
2162 frame_bottomBand = atoi(arg);
2163 if (frame_bottomBand < 0) {
2164 fprintf(stderr, "Incorrect bottom crop size\n");
2167 if ((frame_bottomBand % 2) != 0) {
2168 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2171 if ((frame_bottomBand) >= frame_height){
2172 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2175 frame_height -= frame_bottomBand;
2178 static void opt_frame_crop_left(const char *arg)
2180 frame_leftBand = atoi(arg);
2181 if (frame_leftBand < 0) {
2182 fprintf(stderr, "Incorrect left crop size\n");
2185 if ((frame_leftBand % 2) != 0) {
2186 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2189 if ((frame_leftBand) >= frame_width){
2190 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2193 frame_width -= frame_leftBand;
2196 static void opt_frame_crop_right(const char *arg)
2198 frame_rightBand = atoi(arg);
2199 if (frame_rightBand < 0) {
2200 fprintf(stderr, "Incorrect right crop size\n");
2203 if ((frame_rightBand % 2) != 0) {
2204 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2207 if ((frame_rightBand) >= frame_width){
2208 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2211 frame_width -= frame_rightBand;
2214 static void opt_frame_size(const char *arg)
2216 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2217 fprintf(stderr, "Incorrect frame size\n");
2220 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2221 fprintf(stderr, "Frame size must be a multiple of 2\n");
2227 #define SCALEBITS 10
2228 #define ONE_HALF (1 << (SCALEBITS - 1))
2229 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2231 #define RGB_TO_Y(r, g, b) \
2232 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2233 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2235 #define RGB_TO_U(r1, g1, b1, shift)\
2236 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2237 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2239 #define RGB_TO_V(r1, g1, b1, shift)\
2240 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2241 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2243 static void opt_pad_color(const char *arg) {
2244 /* Input is expected to be six hex digits similar to
2245 how colors are expressed in html tags (but without the #) */
2246 int rgb = strtol(arg, NULL, 16);
2250 g = ((rgb >> 8) & 255);
2253 padcolor[0] = RGB_TO_Y(r,g,b);
2254 padcolor[1] = RGB_TO_U(r,g,b,0);
2255 padcolor[2] = RGB_TO_V(r,g,b,0);
2258 static void opt_frame_pad_top(const char *arg)
2260 frame_padtop = atoi(arg);
2261 if (frame_padtop < 0) {
2262 fprintf(stderr, "Incorrect top pad size\n");
2265 if ((frame_padtop % 2) != 0) {
2266 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2271 static void opt_frame_pad_bottom(const char *arg)
2273 frame_padbottom = atoi(arg);
2274 if (frame_padbottom < 0) {
2275 fprintf(stderr, "Incorrect bottom pad size\n");
2278 if ((frame_padbottom % 2) != 0) {
2279 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2285 static void opt_frame_pad_left(const char *arg)
2287 frame_padleft = atoi(arg);
2288 if (frame_padleft < 0) {
2289 fprintf(stderr, "Incorrect left pad size\n");
2292 if ((frame_padleft % 2) != 0) {
2293 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2299 static void opt_frame_pad_right(const char *arg)
2301 frame_padright = atoi(arg);
2302 if (frame_padright < 0) {
2303 fprintf(stderr, "Incorrect right pad size\n");
2306 if ((frame_padright % 2) != 0) {
2307 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2313 static void opt_frame_pix_fmt(const char *arg)
2315 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2318 static void opt_frame_aspect_ratio(const char *arg)
2324 p = strchr(arg, ':');
2326 x = strtol(arg, (char **)&arg, 10);
2328 y = strtol(arg+1, (char **)&arg, 10);
2330 ar = (double)x / (double)y;
2332 ar = strtod(arg, (char **)&arg);
2335 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2338 frame_aspect_ratio = ar;
2341 static void opt_b_frames(const char *arg)
2343 b_frames = atoi(arg);
2344 if (b_frames > FF_MAX_B_FRAMES) {
2345 fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2347 } else if (b_frames < 1) {
2348 fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2353 static void opt_qscale(const char *arg)
2355 video_qscale = atof(arg);
2356 if (video_qscale <= 0 ||
2357 video_qscale > 255) {
2358 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2363 static void opt_qsquish(const char *arg)
2365 video_qsquish = atof(arg);
2366 if (video_qsquish < 0.0 ||
2367 video_qsquish > 99.0) {
2368 fprintf(stderr, "qsquish must be >= 0.0 and <= 99.0\n");
2373 static void opt_lmax(const char *arg)
2375 video_lmax = atof(arg)*FF_QP2LAMBDA;
2378 static void opt_lmin(const char *arg)
2380 video_lmin = atof(arg)*FF_QP2LAMBDA;
2383 static void opt_qmin(const char *arg)
2385 video_qmin = atoi(arg);
2386 if (video_qmin < 1 ||
2388 fprintf(stderr, "qmin must be >= 1 and <= 51\n");
2393 static void opt_qmax(const char *arg)
2395 video_qmax = atoi(arg);
2396 if (video_qmax < 1 ||
2398 fprintf(stderr, "qmax must be >= 1 and <= 51\n");
2403 static void opt_mb_lmin(const char *arg)
2405 video_mb_lmin = atof(arg)*FF_QP2LAMBDA;
2406 if (video_mb_lmin < 1 ||
2407 video_mb_lmin > FF_LAMBDA_MAX) {
2408 fprintf(stderr, "mblmin must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2413 static void opt_mb_lmax(const char *arg)
2415 video_mb_lmax = atof(arg)*FF_QP2LAMBDA;
2416 if (video_mb_lmax < 1 ||
2417 video_mb_lmax > FF_LAMBDA_MAX) {
2418 fprintf(stderr, "mblmax must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2423 static void opt_qdiff(const char *arg)
2425 video_qdiff = atoi(arg);
2426 if (video_qdiff < 0 ||
2428 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2433 static void opt_packet_size(const char *arg)
2435 packet_size= atoi(arg);
2438 static void opt_error_rate(const char *arg)
2440 error_rate= atoi(arg);
2443 static void opt_strict(const char *arg)
2448 static void opt_top_field_first(const char *arg)
2450 top_field_first= atoi(arg);
2453 static void opt_sc_threshold(const char *arg)
2455 sc_threshold= atoi(arg);
2458 static void opt_thread_count(const char *arg)
2460 thread_count= atoi(arg);
2461 #if !defined(HAVE_THREADS)
2463 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2467 static void opt_audio_bitrate(const char *arg)
2469 audio_bit_rate = atoi(arg) * 1000;
2472 static void opt_audio_rate(const char *arg)
2474 audio_sample_rate = atoi(arg);
2477 static void opt_audio_channels(const char *arg)
2479 audio_channels = atoi(arg);
2482 static void opt_video_device(const char *arg)
2484 video_device = av_strdup(arg);
2487 static void opt_grab_device(const char *arg)
2489 grab_device = av_strdup(arg);
2492 static void opt_video_channel(const char *arg)
2494 video_channel = strtol(arg, NULL, 0);
2497 static void opt_video_standard(const char *arg)
2499 video_standard = av_strdup(arg);
2502 static void opt_audio_device(const char *arg)
2504 audio_device = av_strdup(arg);
2507 static void opt_codec(int *pstream_copy, int *pcodec_id,
2508 int codec_type, const char *arg)
2512 if (!strcmp(arg, "copy")) {
2517 if (!strcmp(p->name, arg) && p->type == codec_type)
2522 fprintf(stderr, "Unknown codec '%s'\n", arg);
2530 static void opt_audio_codec(const char *arg)
2532 opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2535 static void opt_audio_tag(const char *arg)
2538 audio_codec_tag= strtol(arg, &tail, 0);
2541 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2544 static void opt_video_tag(const char *arg)
2547 video_codec_tag= strtol(arg, &tail, 0);
2550 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2553 static void add_frame_hooker(const char *arg)
2558 char *args = av_strdup(arg);
2562 argv[0] = strtok(args, " ");
2563 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2566 i = frame_hook_add(argc, argv);
2569 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2574 const char *motion_str[] = {
2587 static void opt_motion_estimation(const char *arg)
2593 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2596 if (!strcmp(*p, arg))
2600 me_method = (p - motion_str) + 1;
2603 static void opt_video_codec(const char *arg)
2605 opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2608 static void opt_subtitle_codec(const char *arg)
2610 opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2613 static void opt_map(const char *arg)
2619 m = &stream_maps[nb_stream_maps++];
2621 m->file_index = strtol(arg, (char **)&p, 0);
2625 m->stream_index = strtol(p, (char **)&p, 0);
2628 m->sync_file_index = strtol(p, (char **)&p, 0);
2631 m->sync_stream_index = strtol(p, (char **)&p, 0);
2633 m->sync_file_index = m->file_index;
2634 m->sync_stream_index = m->stream_index;
2638 static void opt_map_meta_data(const char *arg)
2644 m = &meta_data_maps[nb_meta_data_maps++];
2646 m->out_file = strtol(arg, (char **)&p, 0);
2650 m->in_file = strtol(p, (char **)&p, 0);
2653 static void opt_recording_time(const char *arg)
2655 recording_time = parse_date(arg, 1);
2658 static void opt_start_time(const char *arg)
2660 start_time = parse_date(arg, 1);
2663 static void opt_rec_timestamp(const char *arg)
2665 rec_timestamp = parse_date(arg, 0) / 1000000;
2668 static void opt_input_ts_offset(const char *arg)
2670 input_ts_offset = parse_date(arg, 1);
2673 static void opt_input_file(const char *filename)
2675 AVFormatContext *ic;
2676 AVFormatParameters params, *ap = ¶ms;
2677 int err, i, ret, rfps, rfps_base;
2680 if (!strcmp(filename, "-"))
2683 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2684 !strcmp( filename, "/dev/stdin" );
2686 /* get default parameters from command line */
2687 ic = av_alloc_format_context();
2689 memset(ap, 0, sizeof(*ap));
2690 ap->prealloced_context = 1;
2691 ap->sample_rate = audio_sample_rate;
2692 ap->channels = audio_channels;
2693 ap->time_base.den = frame_rate;
2694 ap->time_base.num = frame_rate_base;
2695 ap->width = frame_width + frame_padleft + frame_padright;
2696 ap->height = frame_height + frame_padtop + frame_padbottom;
2697 ap->image_format = image_format;
2698 ap->pix_fmt = frame_pix_fmt;
2699 ap->device = grab_device;
2700 ap->channel = video_channel;
2701 ap->standard = video_standard;
2702 ap->video_codec_id = video_codec_id;
2703 ap->audio_codec_id = audio_codec_id;
2704 if(pgmyuv_compatibility_hack)
2705 ap->video_codec_id= CODEC_ID_PGMYUV;
2707 for(i=0; i<opt_name_count; i++){
2709 double d= av_get_double(avformat_opts, opt_names[i], &opt);
2710 if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2711 av_set_double(ic, opt_names[i], d);
2713 /* open the input file with generic libav function */
2714 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2716 print_error(filename, err);
2720 ic->loop_input = loop_input;
2722 /* If not enough info to get the stream parameters, we decode the
2723 first frames to get it. (used in mpeg case for example) */
2724 ret = av_find_stream_info(ic);
2725 if (ret < 0 && verbose >= 0) {
2726 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2730 timestamp = start_time;
2731 /* add the stream start time */
2732 if (ic->start_time != AV_NOPTS_VALUE)
2733 timestamp += ic->start_time;
2735 /* if seeking requested, we execute it */
2736 if (start_time != 0) {
2737 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2739 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2740 filename, (double)timestamp / AV_TIME_BASE);
2742 /* reset seek info */
2746 /* update the current parameters so that they match the one of the input stream */
2747 for(i=0;i<ic->nb_streams;i++) {
2749 AVCodecContext *enc = ic->streams[i]->codec;
2750 #if defined(HAVE_THREADS)
2752 avcodec_thread_init(enc, thread_count);
2754 enc->thread_count= thread_count;
2755 switch(enc->codec_type) {
2756 case CODEC_TYPE_AUDIO:
2757 for(j=0; j<opt_name_count; j++){
2759 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2760 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2761 av_set_double(enc, opt_names[j], d);
2763 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2764 audio_channels = enc->channels;
2765 audio_sample_rate = enc->sample_rate;
2767 ic->streams[i]->discard= AVDISCARD_ALL;
2769 case CODEC_TYPE_VIDEO:
2770 for(j=0; j<opt_name_count; j++){
2772 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2773 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2774 av_set_double(enc, opt_names[j], d);
2776 frame_height = enc->height;
2777 frame_width = enc->width;
2778 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2779 frame_pix_fmt = enc->pix_fmt;
2780 rfps = ic->streams[i]->r_frame_rate.num;
2781 rfps_base = ic->streams[i]->r_frame_rate.den;
2782 enc->workaround_bugs = workaround_bugs;
2783 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2785 enc->debug |= FF_DEBUG_MV;
2787 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2790 fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2791 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2793 (float)rfps / rfps_base, rfps, rfps_base);
2795 /* update the current frame rate to match the stream frame rate */
2797 frame_rate_base = rfps_base;
2799 enc->rate_emu = rate_emu;
2801 ic->streams[i]->discard= AVDISCARD_ALL;
2802 else if(video_discard)
2803 ic->streams[i]->discard= video_discard;
2805 case CODEC_TYPE_DATA:
2807 case CODEC_TYPE_SUBTITLE:
2809 case CODEC_TYPE_UNKNOWN:
2816 input_files[nb_input_files] = ic;
2817 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2818 /* dump the file content */
2820 dump_format(ic, nb_input_files, filename, 0);
2823 file_iformat = NULL;
2824 file_oformat = NULL;
2825 image_format = NULL;
2833 static void opt_grab(const char *arg)
2835 file_iformat = av_find_input_format(arg);
2839 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2841 int has_video, has_audio, i, j;
2842 AVFormatContext *ic;
2846 for(j=0;j<nb_input_files;j++) {
2847 ic = input_files[j];
2848 for(i=0;i<ic->nb_streams;i++) {
2849 AVCodecContext *enc = ic->streams[i]->codec;
2850 switch(enc->codec_type) {
2851 case CODEC_TYPE_AUDIO:
2854 case CODEC_TYPE_VIDEO:
2857 case CODEC_TYPE_DATA:
2858 case CODEC_TYPE_UNKNOWN:
2859 case CODEC_TYPE_SUBTITLE:
2866 *has_video_ptr = has_video;
2867 *has_audio_ptr = has_audio;
2870 static void new_video_stream(AVFormatContext *oc)
2873 AVCodecContext *video_enc;
2876 st = av_new_stream(oc, oc->nb_streams);
2878 fprintf(stderr, "Could not alloc stream\n");
2881 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2882 video_bitstream_filters= NULL;
2884 #if defined(HAVE_THREADS)
2886 avcodec_thread_init(st->codec, thread_count);
2889 video_enc = st->codec;
2892 video_enc->codec_tag= video_codec_tag;
2894 if( (video_global_header&1)
2895 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2896 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2897 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2899 if(video_global_header&2){
2900 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2901 avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2904 if (video_stream_copy) {
2905 st->stream_copy = 1;
2906 video_enc->codec_type = CODEC_TYPE_VIDEO;
2912 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2913 if (video_codec_id != CODEC_ID_NONE)
2914 codec_id = video_codec_id;
2916 video_enc->codec_id = codec_id;
2917 codec = avcodec_find_encoder(codec_id);
2919 for(i=0; i<opt_name_count; i++){
2921 double d= av_get_double(avctx_opts, opt_names[i], &opt);
2922 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2923 av_set_double(video_enc, opt_names[i], d);
2926 video_enc->time_base.den = frame_rate;
2927 video_enc->time_base.num = frame_rate_base;
2928 if(codec && codec->supported_framerates){
2929 const AVRational *p= codec->supported_framerates;
2930 AVRational req= (AVRational){frame_rate, frame_rate_base};
2931 const AVRational *best=NULL;
2932 AVRational best_error= (AVRational){INT_MAX, 1};
2933 for(; p->den!=0; p++){
2934 AVRational error= av_sub_q(req, *p);
2935 if(error.num <0) error.num *= -1;
2936 if(av_cmp_q(error, best_error) < 0){
2941 video_enc->time_base.den= best->num;
2942 video_enc->time_base.num= best->den;
2945 video_enc->width = frame_width + frame_padright + frame_padleft;
2946 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2947 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2948 video_enc->pix_fmt = frame_pix_fmt;
2950 if(codec && codec->pix_fmts){
2951 const enum PixelFormat *p= codec->pix_fmts;
2953 if(*p == video_enc->pix_fmt)
2957 video_enc->pix_fmt = codec->pix_fmts[0];
2961 video_enc->gop_size = 0;
2962 if (video_qscale || same_quality) {
2963 video_enc->flags |= CODEC_FLAG_QSCALE;
2964 video_enc->global_quality=
2965 st->quality = FF_QP2LAMBDA * video_qscale;
2969 video_enc->intra_matrix = intra_matrix;
2971 video_enc->inter_matrix = inter_matrix;
2973 video_enc->max_b_frames = b_frames;
2974 video_enc->qmin = video_qmin;
2975 video_enc->qmax = video_qmax;
2976 video_enc->lmin = video_lmin;
2977 video_enc->lmax = video_lmax;
2978 video_enc->rc_qsquish = video_qsquish;
2979 video_enc->mb_lmin = video_mb_lmin;
2980 video_enc->mb_lmax = video_mb_lmax;
2981 video_enc->max_qdiff = video_qdiff;
2982 video_enc->rc_eq = video_rc_eq;
2983 video_enc->workaround_bugs = workaround_bugs;
2984 video_enc->thread_count = thread_count;
2985 p= video_rc_override_string;
2988 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2990 fprintf(stderr, "error parsing rc_override\n");
2993 video_enc->rc_override=
2994 av_realloc(video_enc->rc_override,
2995 sizeof(RcOverride)*(i+1));
2996 video_enc->rc_override[i].start_frame= start;
2997 video_enc->rc_override[i].end_frame = end;
2999 video_enc->rc_override[i].qscale= q;
3000 video_enc->rc_override[i].quality_factor= 1.0;
3003 video_enc->rc_override[i].qscale= 0;
3004 video_enc->rc_override[i].quality_factor= -q/100.0;
3009 video_enc->rc_override_count=i;
3010 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3011 video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
3012 video_enc->me_threshold= me_threshold;
3013 video_enc->mb_threshold= mb_threshold;
3014 video_enc->intra_dc_precision= intra_dc_precision - 8;
3015 video_enc->strict_std_compliance = strict;
3016 video_enc->error_rate = error_rate;
3017 video_enc->scenechange_threshold= sc_threshold;
3018 video_enc->me_penalty_compensation= me_penalty_compensation;
3019 video_enc->frame_skip_threshold= frame_skip_threshold;
3020 video_enc->frame_skip_factor= frame_skip_factor;
3021 video_enc->frame_skip_exp= frame_skip_exp;
3024 video_enc->rtp_mode= 1;
3025 video_enc->rtp_payload_size= packet_size;
3029 video_enc->flags|= CODEC_FLAG_PSNR;
3031 video_enc->me_method = me_method;
3036 video_enc->flags |= CODEC_FLAG_PASS1;
3038 video_enc->flags |= CODEC_FLAG_PASS2;
3043 /* reset some key parameters */
3045 video_codec_id = CODEC_ID_NONE;
3046 video_stream_copy = 0;
3049 static void new_audio_stream(AVFormatContext *oc)
3052 AVCodecContext *audio_enc;
3055 st = av_new_stream(oc, oc->nb_streams);
3057 fprintf(stderr, "Could not alloc stream\n");
3061 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3062 audio_bitstream_filters= NULL;
3064 #if defined(HAVE_THREADS)
3066 avcodec_thread_init(st->codec, thread_count);
3069 audio_enc = st->codec;
3070 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3073 audio_enc->codec_tag= audio_codec_tag;
3075 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3076 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3077 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
3079 if (audio_stream_copy) {
3080 st->stream_copy = 1;
3081 audio_enc->channels = audio_channels;
3083 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3085 for(i=0; i<opt_name_count; i++){
3087 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3088 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3089 av_set_double(audio_enc, opt_names[i], d);
3092 if (audio_codec_id != CODEC_ID_NONE)
3093 codec_id = audio_codec_id;
3094 audio_enc->codec_id = codec_id;
3096 audio_enc->bit_rate = audio_bit_rate;
3097 if (audio_qscale > QSCALE_NONE) {
3098 audio_enc->flags |= CODEC_FLAG_QSCALE;
3099 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3101 audio_enc->strict_std_compliance = strict;
3102 audio_enc->thread_count = thread_count;
3103 /* For audio codecs other than AC3 or DTS we limit */
3104 /* the number of coded channels to stereo */
3105 if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3106 && codec_id != CODEC_ID_DTS) {
3107 audio_enc->channels = 2;
3109 audio_enc->channels = audio_channels;
3111 audio_enc->sample_rate = audio_sample_rate;
3112 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3113 if (audio_language) {
3114 pstrcpy(st->language, sizeof(st->language), audio_language);
3115 av_free(audio_language);
3116 audio_language = NULL;
3119 /* reset some key parameters */
3121 audio_codec_id = CODEC_ID_NONE;
3122 audio_stream_copy = 0;
3125 static void opt_new_subtitle_stream(void)
3127 AVFormatContext *oc;
3129 AVCodecContext *subtitle_enc;
3132 if (nb_output_files <= 0) {
3133 fprintf(stderr, "At least one output file must be specified\n");
3136 oc = output_files[nb_output_files - 1];
3138 st = av_new_stream(oc, oc->nb_streams);
3140 fprintf(stderr, "Could not alloc stream\n");
3144 subtitle_enc = st->codec;
3145 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3146 if (subtitle_stream_copy) {
3147 st->stream_copy = 1;
3149 for(i=0; i<opt_name_count; i++){
3151 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3152 if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3153 av_set_double(subtitle_enc, opt_names[i], d);
3155 subtitle_enc->codec_id = subtitle_codec_id;
3158 if (subtitle_language) {
3159 pstrcpy(st->language, sizeof(st->language), subtitle_language);
3160 av_free(subtitle_language);
3161 subtitle_language = NULL;
3164 subtitle_codec_id = CODEC_ID_NONE;
3165 subtitle_stream_copy = 0;
3168 static void opt_new_audio_stream(void)
3170 AVFormatContext *oc;
3171 if (nb_output_files <= 0) {
3172 fprintf(stderr, "At least one output file must be specified\n");
3175 oc = output_files[nb_output_files - 1];
3176 new_audio_stream(oc);
3179 static void opt_new_video_stream(void)
3181 AVFormatContext *oc;
3182 if (nb_output_files <= 0) {
3183 fprintf(stderr, "At least one output file must be specified\n");
3186 oc = output_files[nb_output_files - 1];
3187 new_video_stream(oc);
3190 static void opt_output_file(const char *filename)
3192 AVFormatContext *oc;
3193 int use_video, use_audio, input_has_video, input_has_audio, i;
3194 AVFormatParameters params, *ap = ¶ms;
3196 if (!strcmp(filename, "-"))
3199 oc = av_alloc_format_context();
3201 if (!file_oformat) {
3202 file_oformat = guess_format(NULL, filename, NULL);
3203 if (!file_oformat) {
3204 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3210 oc->oformat = file_oformat;
3211 pstrcpy(oc->filename, sizeof(oc->filename), filename);
3213 if (!strcmp(file_oformat->name, "ffm") &&
3214 strstart(filename, "http:", NULL)) {
3215 /* special case for files sent to ffserver: we get the stream
3216 parameters from ffserver */
3217 if (read_ffserver_streams(oc, filename) < 0) {
3218 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3222 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3223 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3225 /* disable if no corresponding type found and at least one
3227 if (nb_input_files > 0) {
3228 check_audio_video_inputs(&input_has_video, &input_has_audio);
3229 if (!input_has_video)
3231 if (!input_has_audio)
3235 /* manual disable */
3236 if (audio_disable) {
3239 if (video_disable) {
3244 new_video_stream(oc);
3248 new_audio_stream(oc);
3251 if (!oc->nb_streams) {
3252 fprintf(stderr, "No audio or video streams available\n");
3256 oc->timestamp = rec_timestamp;
3259 pstrcpy(oc->title, sizeof(oc->title), str_title);
3261 pstrcpy(oc->author, sizeof(oc->author), str_author);
3263 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3265 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3267 pstrcpy(oc->album, sizeof(oc->album), str_album);
3270 output_files[nb_output_files++] = oc;
3272 /* check filename in case of an image number is expected */
3273 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3274 if (!av_filename_number_test(oc->filename)) {
3275 print_error(oc->filename, AVERROR_NUMEXPECTED);
3280 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3281 /* test if it already exists to avoid loosing precious files */
3282 if (!file_overwrite &&
3283 (strchr(filename, ':') == NULL ||
3284 strstart(filename, "file:", NULL))) {
3285 if (url_exist(filename)) {
3288 if ( !using_stdin ) {
3289 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3292 if (toupper(c) != 'Y') {
3293 fprintf(stderr, "Not overwriting - exiting\n");
3298 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3305 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3306 fprintf(stderr, "Could not open '%s'\n", filename);
3311 memset(ap, 0, sizeof(*ap));
3312 ap->image_format = image_format;
3313 if (av_set_parameters(oc, ap) < 0) {
3314 fprintf(stderr, "%s: Invalid encoding parameters\n",
3319 oc->packet_size= mux_packet_size;
3320 oc->mux_rate= mux_rate;
3321 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3322 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3323 oc->loop_output = loop_output;
3325 for(i=0; i<opt_name_count; i++){
3327 double d = av_get_double(avformat_opts, opt_names[i], &opt);
3328 if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3329 av_set_double(oc, opt_names[i], d);
3332 /* reset some options */
3333 file_oformat = NULL;
3334 file_iformat = NULL;
3335 image_format = NULL;
3338 /* prepare dummy protocols for grab */
3339 static void prepare_grab(void)
3341 int has_video, has_audio, i, j;
3342 AVFormatContext *oc;
3343 AVFormatContext *ic;
3344 AVFormatParameters vp1, *vp = &vp1;
3345 AVFormatParameters ap1, *ap = &ap1;
3347 /* see if audio/video inputs are needed */
3350 memset(ap, 0, sizeof(*ap));
3351 memset(vp, 0, sizeof(*vp));
3352 vp->time_base.num= 1;
3353 for(j=0;j<nb_output_files;j++) {
3354 oc = output_files[j];
3355 for(i=0;i<oc->nb_streams;i++) {
3356 AVCodecContext *enc = oc->streams[i]->codec;
3357 switch(enc->codec_type) {
3358 case CODEC_TYPE_AUDIO:
3359 if (enc->sample_rate > ap->sample_rate)
3360 ap->sample_rate = enc->sample_rate;
3361 if (enc->channels > ap->channels)
3362 ap->channels = enc->channels;
3365 case CODEC_TYPE_VIDEO:
3366 if (enc->width > vp->width)
3367 vp->width = enc->width;
3368 if (enc->height > vp->height)
3369 vp->height = enc->height;
3371 if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3372 vp->time_base = enc->time_base;
3373 vp->width += frame_leftBand + frame_rightBand;
3374 vp->width -= (frame_padleft + frame_padright);
3375 vp->height += frame_topBand + frame_bottomBand;
3376 vp->height -= (frame_padtop + frame_padbottom);
3386 if (has_video == 0 && has_audio == 0) {
3387 fprintf(stderr, "Output file must have at least one audio or video stream\n");
3392 AVInputFormat *fmt1;
3393 fmt1 = av_find_input_format(video_grab_format);
3394 vp->device = video_device;
3395 vp->channel = video_channel;
3396 vp->standard = video_standard;
3397 vp->pix_fmt = frame_pix_fmt;
3398 if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3399 fprintf(stderr, "Could not find video grab device\n");
3402 /* If not enough info to get the stream parameters, we decode the
3403 first frames to get it. */
3404 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3405 fprintf(stderr, "Could not find video grab parameters\n");
3408 /* by now video grab has one stream */
3409 ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3410 ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3411 input_files[nb_input_files] = ic;
3414 dump_format(ic, nb_input_files, "", 0);
3418 if (has_audio && audio_grab_format) {
3419 AVInputFormat *fmt1;
3420 fmt1 = av_find_input_format(audio_grab_format);
3421 ap->device = audio_device;
3422 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3423 fprintf(stderr, "Could not find audio grab device\n");
3426 input_files[nb_input_files] = ic;
3429 dump_format(ic, nb_input_files, "", 0);
3435 /* same option as mencoder */
3436 static void opt_pass(const char *pass_str)
3439 pass = atoi(pass_str);
3440 if (pass != 1 && pass != 2) {
3441 fprintf(stderr, "pass number can be only 1 or 2\n");
3447 #if defined(__MINGW32__) || defined(CONFIG_OS2)
3448 static int64_t getutime(void)
3450 return av_gettime();
3453 static int64_t getutime(void)
3455 struct rusage rusage;
3457 getrusage(RUSAGE_SELF, &rusage);
3458 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3462 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3463 extern int ffm_nopts;
3466 static void show_formats(void)
3468 AVInputFormat *ifmt;
3469 AVOutputFormat *ofmt;
3470 AVImageFormat *image_fmt;
3473 const char **pp, *last_name;
3475 printf("File formats:\n");
3480 const char *name=NULL;
3481 const char *long_name=NULL;
3483 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3484 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3485 strcmp(ofmt->name, last_name)>0){
3487 long_name= ofmt->long_name;
3491 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3492 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3493 strcmp(ifmt->name, last_name)>0){
3495 long_name= ifmt->long_name;
3498 if(name && strcmp(ifmt->name, name)==0)
3510 long_name ? long_name:" ");
3514 printf("Image formats (filename extensions, if any, follow):\n");
3515 for(image_fmt = first_image_format; image_fmt != NULL;
3516 image_fmt = image_fmt->next) {
3519 image_fmt->img_read ? "D":" ",
3520 image_fmt->img_write ? "E":" ",
3522 image_fmt->extensions ? image_fmt->extensions:" ");
3526 printf("Codecs:\n");
3532 const char *type_str;
3535 for(p = first_avcodec; p != NULL; p = p->next) {
3536 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3537 strcmp(p->name, last_name)>0){
3539 decode= encode= cap=0;
3541 if(p2 && strcmp(p->name, p2->name)==0){
3542 if(p->decode) decode=1;
3543 if(p->encode) encode=1;
3544 cap |= p->capabilities;
3549 last_name= p2->name;
3552 case CODEC_TYPE_VIDEO:
3555 case CODEC_TYPE_AUDIO:
3558 case CODEC_TYPE_SUBTITLE:
3567 decode ? "D": (/*p2->decoder ? "d":*/" "),
3570 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3571 cap & CODEC_CAP_DR1 ? "D":" ",
3572 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3574 /* if(p2->decoder && decode==0)
3575 printf(" use %s for decoding", p2->decoder->name);*/
3580 printf("Supported file protocols:\n");
3581 for(up = first_protocol; up != NULL; up = up->next)
3582 printf(" %s:", up->name);
3585 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3586 printf("Motion estimation methods:\n");
3590 if ((pp - motion_str + 1) == ME_ZERO)
3591 printf("(fastest)");
3592 else if ((pp - motion_str + 1) == ME_FULL)
3593 printf("(slowest)");
3594 else if ((pp - motion_str + 1) == ME_EPZS)
3595 printf("(default)");
3600 "Note, the names of encoders and decoders dont always match, so there are\n"
3601 "several cases where the above table shows encoder only or decoder only entries\n"
3602 "even though both encoding and decoding are supported for example, the h263\n"
3603 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3608 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3611 const char *p = str;
3618 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3625 static void opt_inter_matrix(const char *arg)
3627 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3628 parse_matrix_coeffs(inter_matrix, arg);
3631 static void opt_intra_matrix(const char *arg)
3633 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3634 parse_matrix_coeffs(intra_matrix, arg);
3637 static void opt_target(const char *arg)
3640 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3642 if(!strncmp(arg, "pal-", 4)) {
3645 } else if(!strncmp(arg, "ntsc-", 5)) {
3648 } else if(!strncmp(arg, "film-", 5)) {
3653 /* Calculate FR via float to avoid int overflow */
3654 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3657 } else if((fr == 29970) || (fr == 23976)) {
3660 /* Try to determine PAL/NTSC by peeking in the input files */
3661 if(nb_input_files) {
3663 for(j = 0; j < nb_input_files; j++) {
3664 for(i = 0; i < input_files[j]->nb_streams; i++) {
3665 AVCodecContext *c = input_files[j]->streams[i]->codec;
3666 if(c->codec_type != CODEC_TYPE_VIDEO)
3668 fr = c->time_base.den * 1000 / c->time_base.num;
3672 } else if((fr == 29970) || (fr == 23976)) {
3682 if(verbose && norm >= 0)
3683 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3687 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3688 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3689 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3693 if(!strcmp(arg, "vcd")) {
3695 opt_video_codec("mpeg1video");
3696 opt_audio_codec("mp2");
3699 opt_frame_size(norm ? "352x240" : "352x288");
3700 opt_frame_rate(frame_rates[norm]);
3701 opt_default("gop", norm ? "18" : "15");
3703 opt_default("b", "1150000");
3704 opt_default("maxrate", "1150000");
3705 opt_default("minrate", "1150000");
3706 opt_default("bufsize", "327680"); // 40*1024*8;
3708 audio_bit_rate = 224000;
3709 audio_sample_rate = 44100;
3711 mux_packet_size= 2324;
3712 mux_rate= 2352 * 75 * 8;
3714 /* We have to offset the PTS, so that it is consistent with the SCR.
3715 SCR starts at 36000, but the first two packs contain only padding
3716 and the first pack from the other stream, respectively, may also have
3717 been written before.
3718 So the real data starts at SCR 36000+3*1200. */
3719 mux_preload= (36000+3*1200) / 90000.0; //0.44
3720 } else if(!strcmp(arg, "svcd")) {
3722 opt_video_codec("mpeg2video");
3723 opt_audio_codec("mp2");
3726 opt_frame_size(norm ? "480x480" : "480x576");
3727 opt_frame_rate(frame_rates[norm]);
3728 opt_default("gop", norm ? "18" : "15");
3730 opt_default("b", "2040000");
3731 opt_default("maxrate", "2516000");
3732 opt_default("minrate", "0"); //1145000;
3733 opt_default("bufsize", "1835008");&n