3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 #define HAVE_AV_CONFIG_H
23 #include "framehook.h"
30 #include <sys/ioctl.h>
33 #include <sys/resource.h>
37 #include <sys/types.h>
38 #include <sys/select.h>
41 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
50 #if !defined(INFINITY) && defined(HUGE_VAL)
51 #define INFINITY HUGE_VAL
54 /* select an input stream for an output stream */
55 typedef struct AVStreamMap {
59 int sync_stream_index;
62 /** select an input file for an output file */
63 typedef struct AVMetaDataMap {
68 extern const OptionDef options[];
70 static void show_help(void);
71 static void show_license(void);
72 static int opt_default(const char *opt, const char *arg);
76 static AVFormatContext *input_files[MAX_FILES];
77 static int64_t input_files_ts_offset[MAX_FILES];
78 static int nb_input_files = 0;
80 static AVFormatContext *output_files[MAX_FILES];
81 static int nb_output_files = 0;
83 static AVStreamMap stream_maps[MAX_FILES];
84 static int nb_stream_maps;
86 static AVMetaDataMap meta_data_maps[MAX_FILES];
87 static int nb_meta_data_maps;
89 static AVInputFormat *file_iformat;
90 static AVOutputFormat *file_oformat;
91 static AVImageFormat *image_format;
92 static int frame_width = 0;
93 static int frame_height = 0;
94 static float frame_aspect_ratio = 0;
95 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
96 static int frame_padtop = 0;
97 static int frame_padbottom = 0;
98 static int frame_padleft = 0;
99 static int frame_padright = 0;
100 static int padcolor[3] = {16,128,128}; /* default to black */
101 static int frame_topBand = 0;
102 static int frame_bottomBand = 0;
103 static int frame_leftBand = 0;
104 static int frame_rightBand = 0;
105 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
106 static int frame_rate = 25;
107 static int frame_rate_base = 1;
108 static float video_qscale = 0;
109 static int video_lmin = 2*FF_QP2LAMBDA;
110 static int video_lmax = 31*FF_QP2LAMBDA;
111 static int video_mb_lmin = 2*FF_QP2LAMBDA;
112 static int video_mb_lmax = 31*FF_QP2LAMBDA;
113 static int video_qdiff = 3;
114 static uint16_t *intra_matrix = NULL;
115 static uint16_t *inter_matrix = NULL;
116 #if 0 //experimental, (can be removed)
117 static float video_rc_qsquish=1.0;
118 static float video_rc_qmod_amp=0;
119 static int video_rc_qmod_freq=0;
121 static char *video_rc_override_string=NULL;
122 static char *video_rc_eq="tex^qComp";
123 static float video_rc_buffer_aggressivity=1.0;
124 static int me_method = ME_EPZS;
125 static int video_disable = 0;
126 static int video_discard = 0;
127 static int video_codec_id = CODEC_ID_NONE;
128 static int video_codec_tag = 0;
129 static int same_quality = 0;
130 static int do_deinterlace = 0;
131 static int packet_size = 0;
132 static int error_rate = 0;
133 static int strict = 0;
134 static int top_field_first = -1;
135 static int me_threshold = 0;
136 static int mb_threshold = 0;
137 static int intra_dc_precision = 8;
138 static int me_penalty_compensation= 256;
139 static int frame_skip_threshold= 0;
140 static int frame_skip_factor= 0;
141 static int frame_skip_exp= 0;
142 static int loop_input = 0;
143 static int loop_output = AVFMT_NOOUTPUTLOOP;
144 static int qp_hist = 0;
146 static int intra_only = 0;
147 static int audio_sample_rate = 44100;
148 static int audio_bit_rate = 64000;
149 #define QSCALE_NONE -99999
150 static float audio_qscale = QSCALE_NONE;
151 static int audio_disable = 0;
152 static int audio_channels = 1;
153 static int audio_codec_id = CODEC_ID_NONE;
154 static int audio_codec_tag = 0;
155 static char *audio_language = NULL;
157 static int subtitle_codec_id = CODEC_ID_NONE;
158 static char *subtitle_language = NULL;
160 static float mux_preload= 0.5;
161 static float mux_max_delay= 0.7;
163 static int64_t recording_time = 0;
164 static int64_t start_time = 0;
165 static int64_t rec_timestamp = 0;
166 static int64_t input_ts_offset = 0;
167 static int file_overwrite = 0;
168 static char *str_title = NULL;
169 static char *str_author = NULL;
170 static char *str_copyright = NULL;
171 static char *str_comment = NULL;
172 static char *str_album = NULL;
173 static int do_benchmark = 0;
174 static int do_hex_dump = 0;
175 static int do_pkt_dump = 0;
176 static int do_psnr = 0;
177 static int do_vstats = 0;
178 static int do_pass = 0;
179 static char *pass_logfilename = NULL;
180 static int audio_stream_copy = 0;
181 static int video_stream_copy = 0;
182 static int subtitle_stream_copy = 0;
183 static int video_sync_method= 1;
184 static int audio_sync_method= 0;
185 static int copy_ts= 0;
186 static int opt_shortest = 0; //
187 static int video_global_header = 0;
189 static int rate_emu = 0;
192 static const char *video_grab_format = "bktr";
194 #ifdef CONFIG_VIDEO4LINUX2
195 static const char *video_grab_format = "video4linux2";
197 static const char *video_grab_format = "video4linux";
200 static char *video_device = NULL;
201 static char *grab_device = NULL;
202 static int video_channel = 0;
203 static char *video_standard = "ntsc";
205 static const char *audio_grab_format = "audio_device";
206 static char *audio_device = NULL;
207 static int audio_volume = 256;
209 static int using_stdin = 0;
210 static int using_vhook = 0;
211 static int verbose = 1;
212 static int thread_count= 1;
213 static int q_pressed = 0;
214 static int64_t video_size = 0;
215 static int64_t audio_size = 0;
216 static int64_t extra_size = 0;
217 static int nb_frames_dup = 0;
218 static int nb_frames_drop = 0;
219 static int input_sync;
220 static int limit_filesize = 0; //
222 static int pgmyuv_compatibility_hack=0;
223 static int dts_delta_threshold = 10;
225 static int sws_flags = SWS_BICUBIC;
227 const char **opt_names=NULL;
228 int opt_name_count=0;
229 AVCodecContext *avctx_opts;
230 AVFormatContext *avformat_opts;
232 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
233 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
234 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
236 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
238 struct AVInputStream;
240 typedef struct AVOutputStream {
241 int file_index; /* file index */
242 int index; /* stream index in the output file */
243 int source_index; /* AVInputStream index */
244 AVStream *st; /* stream in the output file */
245 int encoding_needed; /* true if encoding needed for this stream */
247 /* input pts and corresponding output pts
249 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
250 struct AVInputStream *sync_ist; /* input stream to sync against */
251 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
254 AVFrame pict_tmp; /* temporary image for resampling */
255 struct SwsContext *img_resample_ctx; /* for image resampling */
259 int topBand; /* cropping area sizes */
263 int padtop; /* padding area sizes */
270 ReSampleContext *resample; /* for audio resampling */
271 FifoBuffer fifo; /* for compression: one audio fifo per codec */
275 typedef struct AVInputStream {
279 int discard; /* true if stream data should be discarded */
280 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
281 int64_t sample_index; /* current sample */
283 int64_t start; /* time when read started */
284 unsigned long frame; /* current frame */
285 int64_t next_pts; /* synthetic pts for cases where pkt.pts
287 int64_t pts; /* current pts */
288 int is_start; /* is 1 at the start and after a discontinuity */
291 typedef struct AVInputFile {
292 int eof_reached; /* true if eof reached */
293 int ist_index; /* index of first stream in ist_table */
294 int buffer_size; /* current total buffer size */
295 int buffer_size_max; /* buffer size at which we consider we can stop
297 int nb_streams; /* nb streams we are aware of */
302 /* init terminal so that we can grab keys */
303 static struct termios oldtty;
305 static void term_exit(void)
307 tcsetattr (0, TCSANOW, &oldtty);
310 static volatile sig_atomic_t received_sigterm = 0;
313 sigterm_handler(int sig)
315 received_sigterm = sig;
319 static void term_init(void)
326 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
327 |INLCR|IGNCR|ICRNL|IXON);
328 tty.c_oflag |= OPOST;
329 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
330 tty.c_cflag &= ~(CSIZE|PARENB);
335 tcsetattr (0, TCSANOW, &tty);
337 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
338 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
339 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
341 register a function to be called at normal program termination
344 #ifdef CONFIG_BEOS_NETSERVER
345 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
349 /* read a key without blocking */
350 static int read_key(void)
354 #ifndef CONFIG_BEOS_NETSERVER
362 n = select(1, &rfds, NULL, NULL, &tv);
374 static int decode_interrupt_cb(void)
376 return q_pressed || (q_pressed = read_key() == 'q');
381 static volatile int received_sigterm = 0;
383 /* no interactive support */
384 static void term_exit(void)
388 static void term_init(void)
392 static int read_key(void)
399 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
404 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
407 /* copy stream format */
408 s->nb_streams = ic->nb_streams;
409 for(i=0;i<ic->nb_streams;i++) {
412 // FIXME: a more elegant solution is needed
413 st = av_mallocz(sizeof(AVStream));
414 memcpy(st, ic->streams[i], sizeof(AVStream));
415 st->codec = avcodec_alloc_context();
416 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
420 av_close_input_file(ic);
425 get_sync_ipts(const AVOutputStream *ost)
427 const AVInputStream *ist = ost->sync_ist;
428 return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
431 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
433 AVPacket new_pkt= *pkt;
434 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
435 &new_pkt.data, &new_pkt.size,
436 pkt->data, pkt->size,
437 pkt->flags & PKT_FLAG_KEY);
440 new_pkt.destruct= av_destruct_packet;
447 av_interleaved_write_frame(s, pkt);
450 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
452 static void do_audio_out(AVFormatContext *s,
455 unsigned char *buf, int size)
458 static uint8_t *audio_buf = NULL;
459 static uint8_t *audio_out = NULL;
460 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
462 int size_out, frame_bytes, ret;
463 AVCodecContext *enc= ost->st->codec;
465 /* SC: dynamic allocation of buffers */
467 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
469 audio_out = av_malloc(audio_out_size);
470 if (!audio_buf || !audio_out)
471 return; /* Should signal an error ! */
473 if(audio_sync_method){
474 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
475 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2);
476 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
477 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
479 //FIXME resample delay
480 if(fabs(delta) > 50){
483 byte_delta= FFMAX(byte_delta, -size);
487 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
492 static uint8_t *input_tmp= NULL;
493 input_tmp= av_realloc(input_tmp, byte_delta + size);
495 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
498 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
500 memset(input_tmp, 0, byte_delta);
501 memcpy(input_tmp + byte_delta, buf, size);
505 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
507 }else if(audio_sync_method>1){
508 int comp= clip(delta, -audio_sync_method, audio_sync_method);
509 assert(ost->audio_resample);
511 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
512 // 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));
513 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
517 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
518 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2); //FIXME wrong
520 if (ost->audio_resample) {
522 size_out = audio_resample(ost->resample,
523 (short *)buftmp, (short *)buf,
524 size / (ist->st->codec->channels * 2));
525 size_out = size_out * enc->channels * 2;
531 /* now encode as many frames as possible */
532 if (enc->frame_size > 1) {
533 /* output resampled raw samples */
534 fifo_write(&ost->fifo, buftmp, size_out,
537 frame_bytes = enc->frame_size * 2 * enc->channels;
539 while (fifo_read(&ost->fifo, audio_buf, frame_bytes,
540 &ost->fifo.rptr) == 0) {
542 av_init_packet(&pkt);
544 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
547 pkt.stream_index= ost->index;
550 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
551 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
552 pkt.flags |= PKT_FLAG_KEY;
553 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
555 ost->sync_opts += enc->frame_size;
559 av_init_packet(&pkt);
561 ost->sync_opts += size_out / (2 * enc->channels);
563 /* output a pcm frame */
564 /* XXX: change encoding codec API to avoid this ? */
565 switch(enc->codec->id) {
566 case CODEC_ID_PCM_S32LE:
567 case CODEC_ID_PCM_S32BE:
568 case CODEC_ID_PCM_U32LE:
569 case CODEC_ID_PCM_U32BE:
570 size_out = size_out << 1;
572 case CODEC_ID_PCM_S24LE:
573 case CODEC_ID_PCM_S24BE:
574 case CODEC_ID_PCM_U24LE:
575 case CODEC_ID_PCM_U24BE:
576 case CODEC_ID_PCM_S24DAUD:
577 size_out = size_out / 2 * 3;
579 case CODEC_ID_PCM_S16LE:
580 case CODEC_ID_PCM_S16BE:
581 case CODEC_ID_PCM_U16LE:
582 case CODEC_ID_PCM_U16BE:
585 size_out = size_out >> 1;
588 ret = avcodec_encode_audio(enc, audio_out, size_out,
591 pkt.stream_index= ost->index;
594 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
595 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
596 pkt.flags |= PKT_FLAG_KEY;
597 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
601 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
605 AVPicture picture_tmp;
608 dec = ist->st->codec;
610 /* deinterlace : must be done before any resize */
611 if (do_deinterlace || using_vhook) {
614 /* create temporary picture */
615 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
616 buf = av_malloc(size);
620 picture2 = &picture_tmp;
621 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
624 if(avpicture_deinterlace(picture2, picture,
625 dec->pix_fmt, dec->width, dec->height) < 0) {
626 /* if error, do not deinterlace */
632 img_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
638 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
640 if (picture != picture2)
641 *picture = *picture2;
645 /* we begin to correct av delay at this threshold */
646 #define AV_DELAY_MAX 0.100
648 static void do_subtitle_out(AVFormatContext *s,
654 static uint8_t *subtitle_out = NULL;
655 int subtitle_out_max_size = 65536;
656 int subtitle_out_size, nb, i;
660 if (pts == AV_NOPTS_VALUE) {
661 fprintf(stderr, "Subtitle packets must have a pts\n");
665 enc = ost->st->codec;
668 subtitle_out = av_malloc(subtitle_out_max_size);
671 /* Note: DVB subtitle need one packet to draw them and one other
672 packet to clear them */
673 /* XXX: signal it in the codec context ? */
674 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
679 for(i = 0; i < nb; i++) {
680 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
681 subtitle_out_max_size, sub);
683 av_init_packet(&pkt);
684 pkt.stream_index = ost->index;
685 pkt.data = subtitle_out;
686 pkt.size = subtitle_out_size;
687 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);
688 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
689 /* XXX: the pts correction is handled here. Maybe handling
690 it in the codec would be better */
692 pkt.pts += 90 * sub->start_display_time;
694 pkt.pts += 90 * sub->end_display_time;
696 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
700 static int bit_buffer_size= 1024*256;
701 static uint8_t *bit_buffer= NULL;
703 static void do_video_out(AVFormatContext *s,
709 int nb_frames, i, ret;
710 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
711 AVFrame picture_crop_temp, picture_pad_temp;
712 uint8_t *buf = NULL, *buf1 = NULL;
713 AVCodecContext *enc, *dec;
715 avcodec_get_frame_defaults(&picture_crop_temp);
716 avcodec_get_frame_defaults(&picture_pad_temp);
718 enc = ost->st->codec;
719 dec = ist->st->codec;
721 /* by default, we output a single frame */
726 if(video_sync_method){
728 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
729 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
732 else if (vdelta > 1.1)
733 nb_frames = lrintf(vdelta);
734 //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);
738 fprintf(stderr, "*** drop!\n");
739 }else if (nb_frames > 1) {
740 nb_frames_dup += nb_frames;
742 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
745 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
747 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
751 if (ost->video_crop) {
752 if (img_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
753 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
756 formatted_picture = &picture_crop_temp;
758 formatted_picture = in_picture;
761 final_picture = formatted_picture;
762 padding_src = formatted_picture;
763 resampling_dst = &ost->pict_tmp;
764 if (ost->video_pad) {
765 final_picture = &ost->pict_tmp;
766 if (ost->video_resample) {
767 if (img_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
768 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
771 resampling_dst = &picture_pad_temp;
775 if (ost->video_resample) {
777 final_picture = &ost->pict_tmp;
778 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
779 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
782 if (ost->video_pad) {
783 img_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
784 enc->height, enc->width, enc->pix_fmt,
785 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
788 /* duplicates frame if needed */
789 for(i=0;i<nb_frames;i++) {
791 av_init_packet(&pkt);
792 pkt.stream_index= ost->index;
794 if (s->oformat->flags & AVFMT_RAWPICTURE) {
795 /* raw pictures are written as AVPicture structure to
796 avoid any copies. We support temorarily the older
798 AVFrame* old_frame = enc->coded_frame;
799 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
800 pkt.data= (uint8_t *)final_picture;
801 pkt.size= sizeof(AVPicture);
802 if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
803 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
804 if(dec->coded_frame && dec->coded_frame->key_frame)
805 pkt.flags |= PKT_FLAG_KEY;
807 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
808 enc->coded_frame = old_frame;
812 big_picture= *final_picture;
813 /* better than nothing: use input picture interlaced
815 big_picture.interlaced_frame = in_picture->interlaced_frame;
816 if(avctx_opts->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
817 if(top_field_first == -1)
818 big_picture.top_field_first = in_picture->top_field_first;
820 big_picture.top_field_first = top_field_first;
823 /* handles sameq here. This is not correct because it may
824 not be a global option */
826 big_picture.quality = ist->st->quality;
828 big_picture.quality = ost->st->quality;
830 big_picture.pict_type = 0;
831 // big_picture.pts = AV_NOPTS_VALUE;
832 big_picture.pts= ost->sync_opts;
833 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
834 //av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
835 ret = avcodec_encode_video(enc,
836 bit_buffer, bit_buffer_size,
838 //enc->frame_number = enc->real_pict_num;
840 pkt.data= bit_buffer;
842 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
843 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
844 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n",
845 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
846 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
848 if(enc->coded_frame && enc->coded_frame->key_frame)
849 pkt.flags |= PKT_FLAG_KEY;
850 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
852 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
853 // enc->frame_number-1, enc->real_pict_num, ret,
855 /* if two pass, output log */
856 if (ost->logfile && enc->stats_out) {
857 fprintf(ost->logfile, "%s", enc->stats_out);
869 static double psnr(double d){
870 if(d==0) return INFINITY;
871 return -10.0*log(d)/log(10.0);
874 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
877 static FILE *fvstats=NULL;
884 double ti1, bitrate, avg_bitrate;
888 today = localtime(&today2);
889 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
892 fvstats = fopen(filename,"w");
900 enc = ost->st->codec;
901 if (enc->codec_type == CODEC_TYPE_VIDEO) {
902 frame_number = ost->frame_number;
903 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
904 if (enc->flags&CODEC_FLAG_PSNR)
905 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
907 fprintf(fvstats,"f_size= %6d ", frame_size);
908 /* compute pts value */
909 ti1 = ost->sync_opts * av_q2d(enc->time_base);
913 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
914 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
915 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
916 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
917 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
921 static void print_report(AVFormatContext **output_files,
922 AVOutputStream **ost_table, int nb_ostreams,
927 AVFormatContext *oc, *os;
930 int frame_number, vid, i;
931 double bitrate, ti1, pts;
932 static int64_t last_time = -1;
933 static int qp_histogram[52];
935 if (!is_last_report) {
937 /* display the report every 0.5 seconds */
938 cur_time = av_gettime();
939 if (last_time == -1) {
940 last_time = cur_time;
943 if ((cur_time - last_time) < 500000)
945 last_time = cur_time;
949 oc = output_files[0];
951 total_size = url_ftell(&oc->pb);
956 for(i=0;i<nb_ostreams;i++) {
958 os = output_files[ost->file_index];
959 enc = ost->st->codec;
960 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
961 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
962 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
964 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
965 frame_number = ost->frame_number;
966 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%3.1f ",
967 frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
969 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
970 if(qp_hist && enc->coded_frame){
972 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
973 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
976 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
978 if (enc->flags&CODEC_FLAG_PSNR){
980 double error, error_sum=0;
981 double scale, scale_sum=0;
982 char type[3]= {'Y','U','V'};
983 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
986 error= enc->error[j];
987 scale= enc->width*enc->height*255.0*255.0*frame_number;
989 error= enc->coded_frame->error[j];
990 scale= enc->width*enc->height*255.0*255.0;
995 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
997 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1001 /* compute min output value */
1002 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1003 if ((pts < ti1) && (pts > 0))
1009 if (verbose || is_last_report) {
1010 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1012 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1013 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1014 (double)total_size / 1024, ti1, bitrate);
1017 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1018 nb_frames_dup, nb_frames_drop);
1021 fprintf(stderr, "%s \r", buf);
1026 if (is_last_report && verbose >= 0){
1027 int64_t raw= audio_size + video_size + extra_size;
1028 fprintf(stderr, "\n");
1029 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1033 100.0*(total_size - raw)/raw
1038 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1039 static int output_packet(AVInputStream *ist, int ist_index,
1040 AVOutputStream **ost_table, int nb_ostreams,
1041 const AVPacket *pkt)
1043 AVFormatContext *os;
1044 AVOutputStream *ost;
1048 int data_size, got_picture;
1050 void *buffer_to_free;
1051 static unsigned int samples_size= 0;
1052 static short *samples= NULL;
1053 AVSubtitle subtitle, *subtitle_to_free;
1057 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1058 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1059 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1061 // assert(ist->pts == ist->next_pts);
1075 /* decode the packet if needed */
1076 data_buf = NULL; /* fail safe */
1078 subtitle_to_free = NULL;
1079 if (ist->decoding_needed) {
1080 switch(ist->st->codec->codec_type) {
1081 case CODEC_TYPE_AUDIO:{
1083 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1084 /* XXX: could avoid copy if PCM 16 bits with same
1085 endianness as CPU */
1086 ret = avcodec_decode_audio(ist->st->codec, samples, &data_size,
1092 /* Some bug in mpeg audio decoder gives */
1093 /* data_size < 0, it seems they are overflows */
1094 if (data_size <= 0) {
1095 /* no audio frame */
1098 data_buf = (uint8_t *)samples;
1099 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1100 (ist->st->codec->sample_rate * ist->st->codec->channels);
1102 case CODEC_TYPE_VIDEO:
1103 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1104 /* XXX: allocate picture correctly */
1105 avcodec_get_frame_defaults(&picture);
1107 ret = avcodec_decode_video(ist->st->codec,
1108 &picture, &got_picture, ptr, len);
1109 ist->st->quality= picture.quality;
1113 /* no picture yet */
1114 goto discard_packet;
1116 if (ist->st->codec->time_base.num != 0) {
1117 ist->next_pts += ((int64_t)AV_TIME_BASE *
1118 ist->st->codec->time_base.num) /
1119 ist->st->codec->time_base.den;
1123 case CODEC_TYPE_SUBTITLE:
1124 ret = avcodec_decode_subtitle(ist->st->codec,
1125 &subtitle, &got_subtitle, ptr, len);
1128 if (!got_subtitle) {
1129 goto discard_packet;
1131 subtitle_to_free = &subtitle;
1138 switch(ist->st->codec->codec_type) {
1139 case CODEC_TYPE_AUDIO:
1140 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1141 (ist->st->codec->sample_rate * ist->st->codec->channels);
1143 case CODEC_TYPE_VIDEO:
1144 if (ist->st->codec->time_base.num != 0) {
1145 ist->next_pts += ((int64_t)AV_TIME_BASE *
1146 ist->st->codec->time_base.num) /
1147 ist->st->codec->time_base.den;
1157 buffer_to_free = NULL;
1158 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1159 pre_process_video_frame(ist, (AVPicture *)&picture,
1163 // preprocess audio (volume)
1164 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1165 if (audio_volume != 256) {
1168 for(i=0;i<(data_size / sizeof(short));i++) {
1169 int v = ((*volp) * audio_volume + 128) >> 8;
1170 if (v < -32768) v = -32768;
1171 if (v > 32767) v = 32767;
1177 /* frame rate emulation */
1178 if (ist->st->codec->rate_emu) {
1179 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1180 int64_t now = av_gettime() - ist->start;
1188 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1189 is the one of the next displayed one */
1190 /* XXX: add mpeg4 too ? */
1191 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1192 if (ist->st->codec->pict_type != B_TYPE) {
1194 tmp = ist->last_ip_pts;
1195 ist->last_ip_pts = ist->frac_pts.val;
1196 ist->frac_pts.val = tmp;
1200 /* if output time reached then transcode raw format,
1201 encode packets and output them */
1202 if (start_time == 0 || ist->pts >= start_time)
1203 for(i=0;i<nb_ostreams;i++) {
1207 if (ost->source_index == ist_index) {
1208 os = output_files[ost->file_index];
1211 printf("%d: got pts=%0.3f %0.3f\n", i,
1212 (double)pkt->pts / AV_TIME_BASE,
1213 ((double)ist->pts / AV_TIME_BASE) -
1214 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1216 /* set the input output pts pairs */
1217 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1219 if (ost->encoding_needed) {
1220 switch(ost->st->codec->codec_type) {
1221 case CODEC_TYPE_AUDIO:
1222 do_audio_out(os, ost, ist, data_buf, data_size);
1224 case CODEC_TYPE_VIDEO:
1225 do_video_out(os, ost, ist, &picture, &frame_size);
1226 video_size += frame_size;
1227 if (do_vstats && frame_size)
1228 do_video_stats(os, ost, frame_size);
1230 case CODEC_TYPE_SUBTITLE:
1231 do_subtitle_out(os, ost, ist, &subtitle,
1238 AVFrame avframe; //FIXME/XXX remove this
1240 av_init_packet(&opkt);
1242 /* no reencoding needed : output the packet directly */
1243 /* force the input stream PTS */
1245 avcodec_get_frame_defaults(&avframe);
1246 ost->st->codec->coded_frame= &avframe;
1247 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1249 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1250 audio_size += data_size;
1251 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1252 video_size += data_size;
1256 opkt.stream_index= ost->index;
1257 if(pkt->pts != AV_NOPTS_VALUE)
1258 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);
1260 opkt.pts= AV_NOPTS_VALUE;
1264 if (pkt->dts == AV_NOPTS_VALUE)
1265 dts = ist->next_pts;
1267 dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1268 opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
1270 opkt.flags= pkt->flags;
1272 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1273 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1274 opkt.destruct= av_destruct_packet;
1276 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1277 ost->st->codec->frame_number++;
1278 ost->frame_number++;
1279 av_free_packet(&opkt);
1283 av_free(buffer_to_free);
1284 /* XXX: allocate the subtitles in the codec ? */
1285 if (subtitle_to_free) {
1286 if (subtitle_to_free->rects != NULL) {
1287 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1288 av_free(subtitle_to_free->rects[i].bitmap);
1289 av_free(subtitle_to_free->rects[i].rgba_palette);
1291 av_freep(&subtitle_to_free->rects);
1293 subtitle_to_free->num_rects = 0;
1294 subtitle_to_free = NULL;
1301 for(i=0;i<nb_ostreams;i++) {
1303 if (ost->source_index == ist_index) {
1304 AVCodecContext *enc= ost->st->codec;
1305 os = output_files[ost->file_index];
1307 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1309 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1312 if (ost->encoding_needed) {
1316 av_init_packet(&pkt);
1317 pkt.stream_index= ost->index;
1319 switch(ost->st->codec->codec_type) {
1320 case CODEC_TYPE_AUDIO:
1321 fifo_bytes = fifo_size(&ost->fifo, NULL);
1323 /* encode any samples remaining in fifo */
1324 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1325 int fs_tmp = enc->frame_size;
1326 enc->frame_size = fifo_bytes / (2 * enc->channels);
1327 if(fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes,
1328 &ost->fifo.rptr) == 0) {
1329 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1331 enc->frame_size = fs_tmp;
1334 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1337 pkt.flags |= PKT_FLAG_KEY;
1339 case CODEC_TYPE_VIDEO:
1340 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1342 if(enc->coded_frame && enc->coded_frame->key_frame)
1343 pkt.flags |= PKT_FLAG_KEY;
1344 if (ost->logfile && enc->stats_out) {
1345 fprintf(ost->logfile, "%s", enc->stats_out);
1354 pkt.data= bit_buffer;
1356 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1357 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1358 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1372 * The following code is the main loop of the file converter
1374 static int av_encode(AVFormatContext **output_files,
1375 int nb_output_files,
1376 AVFormatContext **input_files,
1378 AVStreamMap *stream_maps, int nb_stream_maps)
1380 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1381 AVFormatContext *is, *os;
1382 AVCodecContext *codec, *icodec;
1383 AVOutputStream *ost, **ost_table = NULL;
1384 AVInputStream *ist, **ist_table = NULL;
1385 AVInputFile *file_table;
1386 AVFormatContext *stream_no_data;
1389 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1393 /* input stream init */
1395 for(i=0;i<nb_input_files;i++) {
1396 is = input_files[i];
1397 file_table[i].ist_index = j;
1398 file_table[i].nb_streams = is->nb_streams;
1399 j += is->nb_streams;
1403 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1407 for(i=0;i<nb_istreams;i++) {
1408 ist = av_mallocz(sizeof(AVInputStream));
1414 for(i=0;i<nb_input_files;i++) {
1415 is = input_files[i];
1416 for(k=0;k<is->nb_streams;k++) {
1417 ist = ist_table[j++];
1418 ist->st = is->streams[k];
1419 ist->file_index = i;
1421 ist->discard = 1; /* the stream is discarded by default
1424 if (ist->st->codec->rate_emu) {
1425 ist->start = av_gettime();
1431 /* output stream init */
1433 for(i=0;i<nb_output_files;i++) {
1434 os = output_files[i];
1435 nb_ostreams += os->nb_streams;
1437 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1438 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1442 /* Sanity check the mapping args -- do the input files & streams exist? */
1443 for(i=0;i<nb_stream_maps;i++) {
1444 int fi = stream_maps[i].file_index;
1445 int si = stream_maps[i].stream_index;
1447 if (fi < 0 || fi > nb_input_files - 1 ||
1448 si < 0 || si > file_table[fi].nb_streams - 1) {
1449 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1452 fi = stream_maps[i].sync_file_index;
1453 si = stream_maps[i].sync_stream_index;
1454 if (fi < 0 || fi > nb_input_files - 1 ||
1455 si < 0 || si > file_table[fi].nb_streams - 1) {
1456 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1461 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1464 for(i=0;i<nb_ostreams;i++) {
1465 ost = av_mallocz(sizeof(AVOutputStream));
1472 for(k=0;k<nb_output_files;k++) {
1473 os = output_files[k];
1474 for(i=0;i<os->nb_streams;i++) {
1476 ost = ost_table[n++];
1477 ost->file_index = k;
1479 ost->st = os->streams[i];
1480 if (nb_stream_maps > 0) {
1481 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1482 stream_maps[n-1].stream_index;
1484 /* Sanity check that the stream types match */
1485 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1486 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1487 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1488 ost->file_index, ost->index);
1493 /* get corresponding input stream index : we select the first one with the right type */
1495 for(j=0;j<nb_istreams;j++) {
1498 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1499 ost->source_index = j;
1506 /* try again and reuse existing stream */
1507 for(j=0;j<nb_istreams;j++) {
1509 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1510 ost->source_index = j;
1515 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1516 ost->file_index, ost->index);
1521 ist = ist_table[ost->source_index];
1523 ost->sync_ist = (nb_stream_maps > 0) ?
1524 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1525 stream_maps[n-1].sync_stream_index] : ist;
1529 /* for each output stream, we compute the right encoding parameters */
1530 for(i=0;i<nb_ostreams;i++) {
1532 ist = ist_table[ost->source_index];
1534 codec = ost->st->codec;
1535 icodec = ist->st->codec;
1537 if (ost->st->stream_copy) {
1538 /* if stream_copy is selected, no need to decode or encode */
1539 codec->codec_id = icodec->codec_id;
1540 codec->codec_type = icodec->codec_type;
1541 if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1542 codec->bit_rate = icodec->bit_rate;
1543 codec->extradata= icodec->extradata;
1544 codec->extradata_size= icodec->extradata_size;
1545 codec->time_base = icodec->time_base;
1546 switch(codec->codec_type) {
1547 case CODEC_TYPE_AUDIO:
1548 codec->sample_rate = icodec->sample_rate;
1549 codec->channels = icodec->channels;
1550 codec->frame_size = icodec->frame_size;
1551 codec->block_align= icodec->block_align;
1553 case CODEC_TYPE_VIDEO:
1554 codec->pix_fmt = icodec->pix_fmt;
1555 codec->width = icodec->width;
1556 codec->height = icodec->height;
1557 codec->has_b_frames = icodec->has_b_frames;
1559 case CODEC_TYPE_SUBTITLE:
1565 switch(codec->codec_type) {
1566 case CODEC_TYPE_AUDIO:
1567 if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1570 if (codec->channels == icodec->channels &&
1571 codec->sample_rate == icodec->sample_rate) {
1572 ost->audio_resample = 0;
1574 if (codec->channels != icodec->channels &&
1575 (icodec->codec_id == CODEC_ID_AC3 ||
1576 icodec->codec_id == CODEC_ID_DTS)) {
1577 /* Special case for 5:1 AC3 and DTS input */
1578 /* and mono or stereo output */
1579 /* Request specific number of channels */
1580 icodec->channels = codec->channels;
1581 if (codec->sample_rate == icodec->sample_rate)
1582 ost->audio_resample = 0;
1584 ost->audio_resample = 1;
1587 ost->audio_resample = 1;
1590 if(audio_sync_method>1)
1591 ost->audio_resample = 1;
1593 if(ost->audio_resample){
1594 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1595 codec->sample_rate, icodec->sample_rate);
1597 printf("Can't resample. Aborting.\n");
1601 ist->decoding_needed = 1;
1602 ost->encoding_needed = 1;
1604 case CODEC_TYPE_VIDEO:
1605 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1606 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1607 ost->video_resample = ((codec->width != icodec->width -
1608 (frame_leftBand + frame_rightBand) +
1609 (frame_padleft + frame_padright)) ||
1610 (codec->height != icodec->height -
1611 (frame_topBand + frame_bottomBand) +
1612 (frame_padtop + frame_padbottom)) ||
1613 (codec->pix_fmt != icodec->pix_fmt));
1614 if (ost->video_crop) {
1615 ost->topBand = frame_topBand;
1616 ost->leftBand = frame_leftBand;
1618 if (ost->video_pad) {
1619 ost->padtop = frame_padtop;
1620 ost->padleft = frame_padleft;
1621 ost->padbottom = frame_padbottom;
1622 ost->padright = frame_padright;
1623 if (!ost->video_resample) {
1624 avcodec_get_frame_defaults(&ost->pict_tmp);
1625 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1626 codec->width, codec->height ) )
1630 if (ost->video_resample) {
1631 avcodec_get_frame_defaults(&ost->pict_tmp);
1632 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1633 codec->width, codec->height ) )
1636 ost->img_resample_ctx = sws_getContext(
1637 icodec->width - (frame_leftBand + frame_rightBand),
1638 icodec->height - (frame_topBand + frame_bottomBand),
1640 codec->width - (frame_padleft + frame_padright),
1641 codec->height - (frame_padtop + frame_padbottom),
1643 sws_flags, NULL, NULL, NULL);
1644 if (ost->img_resample_ctx == NULL) {
1645 fprintf(stderr, "Cannot get resampling context\n");
1648 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1650 ost->encoding_needed = 1;
1651 ist->decoding_needed = 1;
1653 case CODEC_TYPE_SUBTITLE:
1654 ost->encoding_needed = 1;
1655 ist->decoding_needed = 1;
1662 if (ost->encoding_needed &&
1663 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1664 char logfilename[1024];
1669 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1671 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1672 if (codec->flags & CODEC_FLAG_PASS1) {
1673 f = fopen(logfilename, "w");
1675 perror(logfilename);
1680 /* read the log file */
1681 f = fopen(logfilename, "r");
1683 perror(logfilename);
1686 fseek(f, 0, SEEK_END);
1688 fseek(f, 0, SEEK_SET);
1689 logbuffer = av_malloc(size + 1);
1691 fprintf(stderr, "Could not allocate log buffer\n");
1694 size = fread(logbuffer, 1, size, f);
1696 logbuffer[size] = '\0';
1697 codec->stats_in = logbuffer;
1701 if(codec->codec_type == CODEC_TYPE_VIDEO){
1702 int size= codec->width * codec->height;
1703 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1708 bit_buffer = av_malloc(bit_buffer_size);
1712 /* dump the file output parameters - cannot be done before in case
1714 for(i=0;i<nb_output_files;i++) {
1715 dump_format(output_files[i], i, output_files[i]->filename, 1);
1718 /* dump the stream mapping */
1720 fprintf(stderr, "Stream mapping:\n");
1721 for(i=0;i<nb_ostreams;i++) {
1723 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1724 ist_table[ost->source_index]->file_index,
1725 ist_table[ost->source_index]->index,
1728 if (ost->sync_ist != ist_table[ost->source_index])
1729 fprintf(stderr, " [sync #%d.%d]",
1730 ost->sync_ist->file_index,
1731 ost->sync_ist->index);
1732 fprintf(stderr, "\n");
1736 /* open each encoder */
1737 for(i=0;i<nb_ostreams;i++) {
1739 if (ost->encoding_needed) {
1741 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1743 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1744 ost->file_index, ost->index);
1747 if (avcodec_open(ost->st->codec, codec) < 0) {
1748 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1749 ost->file_index, ost->index);
1752 extra_size += ost->st->codec->extradata_size;
1756 /* open each decoder */
1757 for(i=0;i<nb_istreams;i++) {
1759 if (ist->decoding_needed) {
1761 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1763 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1764 ist->st->codec->codec_id, ist->file_index, ist->index);
1767 if (avcodec_open(ist->st->codec, codec) < 0) {
1768 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1769 ist->file_index, ist->index);
1772 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1773 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1778 for(i=0;i<nb_istreams;i++) {
1780 is = input_files[ist->file_index];
1782 ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1783 if(ist->st->start_time == AV_NOPTS_VALUE)
1785 if(input_files_ts_offset[ist->file_index])
1786 ist->next_pts= AV_NOPTS_VALUE;
1790 /* compute buffer size max (should use a complete heuristic) */
1791 for(i=0;i<nb_input_files;i++) {
1792 file_table[i].buffer_size_max = 2048;
1795 /* set meta data information from input file if required */
1796 for (i=0;i<nb_meta_data_maps;i++) {
1797 AVFormatContext *out_file;
1798 AVFormatContext *in_file;
1800 int out_file_index = meta_data_maps[i].out_file;
1801 int in_file_index = meta_data_maps[i].in_file;
1802 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1803 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1807 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1808 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1813 out_file = output_files[out_file_index];
1814 in_file = input_files[in_file_index];
1816 strcpy(out_file->title, in_file->title);
1817 strcpy(out_file->author, in_file->author);
1818 strcpy(out_file->copyright, in_file->copyright);
1819 strcpy(out_file->comment, in_file->comment);
1820 strcpy(out_file->album, in_file->album);
1821 out_file->year = in_file->year;
1822 out_file->track = in_file->track;
1823 strcpy(out_file->genre, in_file->genre);
1826 /* open files and write file headers */
1827 for(i=0;i<nb_output_files;i++) {
1828 os = output_files[i];
1829 if (av_write_header(os) < 0) {
1830 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1837 if ( !using_stdin && verbose >= 0) {
1838 fprintf(stderr, "Press [q] to stop encoding\n");
1839 url_set_interrupt_cb(decode_interrupt_cb);
1847 for(; received_sigterm == 0;) {
1848 int file_index, ist_index;
1856 /* if 'q' pressed, exits */
1860 /* read_key() returns 0 on EOF */
1866 /* select the stream that we must read now by looking at the
1867 smallest output pts */
1869 for(i=0;i<nb_ostreams;i++) {
1872 os = output_files[ost->file_index];
1873 ist = ist_table[ost->source_index];
1874 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1875 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1877 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1878 ipts = (double)ist->pts;
1879 if (!file_table[ist->file_index].eof_reached){
1880 if(ipts < ipts_min) {
1882 if(input_sync ) file_index = ist->file_index;
1884 if(opts < opts_min) {
1886 if(!input_sync) file_index = ist->file_index;
1889 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1894 /* if none, if is finished */
1895 if (file_index < 0) {
1899 /* finish if recording time exhausted */
1900 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1903 /* finish if limit size exhausted */
1904 if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1907 /* read a frame from it and output it in the fifo */
1908 is = input_files[file_index];
1909 if (av_read_frame(is, &pkt) < 0) {
1910 file_table[file_index].eof_reached = 1;
1911 if (opt_shortest) break; else continue; //
1915 stream_no_data = is;
1920 av_pkt_dump(stdout, &pkt, do_hex_dump);
1922 /* the following test is needed in case new streams appear
1923 dynamically in stream : we ignore them */
1924 if (pkt.stream_index >= file_table[file_index].nb_streams)
1925 goto discard_packet;
1926 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1927 ist = ist_table[ist_index];
1929 goto discard_packet;
1931 // 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);
1932 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1933 int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1934 if(ABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1935 input_files_ts_offset[ist->file_index]-= delta;
1937 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1938 for(i=0; i<file_table[file_index].nb_streams; i++){
1939 int index= file_table[file_index].ist_index + i;
1940 ist_table[index]->next_pts += delta;
1941 ist_table[index]->is_start=1;
1946 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1947 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1950 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1951 ist->file_index, ist->index);
1953 av_free_packet(&pkt);
1958 av_free_packet(&pkt);
1960 /* dump report by using the output first video and audio streams */
1961 print_report(output_files, ost_table, nb_ostreams, 0);
1964 /* at the end of stream, we must flush the decoder buffers */
1965 for(i=0;i<nb_istreams;i++) {
1967 if (ist->decoding_needed) {
1968 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1974 /* write the trailer if needed and close file */
1975 for(i=0;i<nb_output_files;i++) {
1976 os = output_files[i];
1977 av_write_trailer(os);
1980 /* dump report by using the first video and audio streams */
1981 print_report(output_files, ost_table, nb_ostreams, 1);
1983 /* close each encoder */
1984 for(i=0;i<nb_ostreams;i++) {
1986 if (ost->encoding_needed) {
1987 av_freep(&ost->st->codec->stats_in);
1988 avcodec_close(ost->st->codec);
1992 /* close each decoder */
1993 for(i=0;i<nb_istreams;i++) {
1995 if (ist->decoding_needed) {
1996 avcodec_close(ist->st->codec);
2004 av_freep(&bit_buffer);
2005 av_free(file_table);
2008 for(i=0;i<nb_istreams;i++) {
2015 for(i=0;i<nb_ostreams;i++) {
2019 fclose(ost->logfile);
2020 ost->logfile = NULL;
2022 fifo_free(&ost->fifo); /* works even if fifo is not
2023 initialized but set to zero */
2024 av_free(ost->pict_tmp.data[0]);
2025 if (ost->video_resample)
2026 sws_freeContext(ost->img_resample_ctx);
2027 if (ost->audio_resample)
2028 audio_resample_close(ost->resample);
2041 int file_read(const char *filename)
2044 unsigned char buffer[1024];
2047 if (url_open(&h, filename, O_RDONLY) < 0) {
2048 printf("could not open '%s'\n", filename);
2052 len = url_read(h, buffer, sizeof(buffer));
2055 for(i=0;i<len;i++) putchar(buffer[i]);
2062 static void opt_image_format(const char *arg)
2066 for(f = first_image_format; f != NULL; f = f->next) {
2067 if (!strcmp(arg, f->name))
2071 fprintf(stderr, "Unknown image format: '%s'\n", arg);
2077 static void opt_format(const char *arg)
2079 /* compatibility stuff for pgmyuv */
2080 if (!strcmp(arg, "pgmyuv")) {
2081 pgmyuv_compatibility_hack=1;
2082 // opt_image_format(arg);
2086 file_iformat = av_find_input_format(arg);
2087 file_oformat = guess_format(arg, NULL, NULL);
2088 if (!file_iformat && !file_oformat) {
2089 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2094 static void opt_video_rc_eq(char *arg)
2099 static void opt_video_rc_override_string(char *arg)
2101 video_rc_override_string = arg;
2104 static void opt_me_threshold(const char *arg)
2106 me_threshold = atoi(arg);
2109 static void opt_mb_threshold(const char *arg)
2111 mb_threshold = atoi(arg);
2114 static void opt_verbose(const char *arg)
2116 verbose = atoi(arg);
2117 av_log_set_level(atoi(arg));
2120 static void opt_frame_rate(const char *arg)
2122 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2123 fprintf(stderr, "Incorrect frame rate\n");
2128 static void opt_frame_crop_top(const char *arg)
2130 frame_topBand = atoi(arg);
2131 if (frame_topBand < 0) {
2132 fprintf(stderr, "Incorrect top crop size\n");
2135 if ((frame_topBand % 2) != 0) {
2136 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2139 if ((frame_topBand) >= frame_height){
2140 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2143 frame_height -= frame_topBand;
2146 static void opt_frame_crop_bottom(const char *arg)
2148 frame_bottomBand = atoi(arg);
2149 if (frame_bottomBand < 0) {
2150 fprintf(stderr, "Incorrect bottom crop size\n");
2153 if ((frame_bottomBand % 2) != 0) {
2154 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2157 if ((frame_bottomBand) >= frame_height){
2158 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2161 frame_height -= frame_bottomBand;
2164 static void opt_frame_crop_left(const char *arg)
2166 frame_leftBand = atoi(arg);
2167 if (frame_leftBand < 0) {
2168 fprintf(stderr, "Incorrect left crop size\n");
2171 if ((frame_leftBand % 2) != 0) {
2172 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2175 if ((frame_leftBand) >= frame_width){
2176 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2179 frame_width -= frame_leftBand;
2182 static void opt_frame_crop_right(const char *arg)
2184 frame_rightBand = atoi(arg);
2185 if (frame_rightBand < 0) {
2186 fprintf(stderr, "Incorrect right crop size\n");
2189 if ((frame_rightBand % 2) != 0) {
2190 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2193 if ((frame_rightBand) >= frame_width){
2194 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2197 frame_width -= frame_rightBand;
2200 static void opt_frame_size(const char *arg)
2202 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2203 fprintf(stderr, "Incorrect frame size\n");
2206 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2207 fprintf(stderr, "Frame size must be a multiple of 2\n");
2213 #define SCALEBITS 10
2214 #define ONE_HALF (1 << (SCALEBITS - 1))
2215 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2217 #define RGB_TO_Y(r, g, b) \
2218 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2219 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2221 #define RGB_TO_U(r1, g1, b1, shift)\
2222 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2223 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2225 #define RGB_TO_V(r1, g1, b1, shift)\
2226 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2227 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2229 static void opt_pad_color(const char *arg) {
2230 /* Input is expected to be six hex digits similar to
2231 how colors are expressed in html tags (but without the #) */
2232 int rgb = strtol(arg, NULL, 16);
2236 g = ((rgb >> 8) & 255);
2239 padcolor[0] = RGB_TO_Y(r,g,b);
2240 padcolor[1] = RGB_TO_U(r,g,b,0);
2241 padcolor[2] = RGB_TO_V(r,g,b,0);
2244 static void opt_frame_pad_top(const char *arg)
2246 frame_padtop = atoi(arg);
2247 if (frame_padtop < 0) {
2248 fprintf(stderr, "Incorrect top pad size\n");
2251 if ((frame_padtop % 2) != 0) {
2252 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2257 static void opt_frame_pad_bottom(const char *arg)
2259 frame_padbottom = atoi(arg);
2260 if (frame_padbottom < 0) {
2261 fprintf(stderr, "Incorrect bottom pad size\n");
2264 if ((frame_padbottom % 2) != 0) {
2265 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2271 static void opt_frame_pad_left(const char *arg)
2273 frame_padleft = atoi(arg);
2274 if (frame_padleft < 0) {
2275 fprintf(stderr, "Incorrect left pad size\n");
2278 if ((frame_padleft % 2) != 0) {
2279 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2285 static void opt_frame_pad_right(const char *arg)
2287 frame_padright = atoi(arg);
2288 if (frame_padright < 0) {
2289 fprintf(stderr, "Incorrect right pad size\n");
2292 if ((frame_padright % 2) != 0) {
2293 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2299 static void opt_frame_pix_fmt(const char *arg)
2301 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2304 static void opt_frame_aspect_ratio(const char *arg)
2310 p = strchr(arg, ':');
2312 x = strtol(arg, (char **)&arg, 10);
2314 y = strtol(arg+1, (char **)&arg, 10);
2316 ar = (double)x / (double)y;
2318 ar = strtod(arg, (char **)&arg);
2321 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2324 frame_aspect_ratio = ar;
2327 static void opt_qscale(const char *arg)
2329 video_qscale = atof(arg);
2330 if (video_qscale <= 0 ||
2331 video_qscale > 255) {
2332 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2337 static void opt_lmax(const char *arg)
2339 video_lmax = atof(arg)*FF_QP2LAMBDA;
2342 static void opt_lmin(const char *arg)
2344 video_lmin = atof(arg)*FF_QP2LAMBDA;
2347 static void opt_mb_lmin(const char *arg)
2349 video_mb_lmin = atof(arg)*FF_QP2LAMBDA;
2350 if (video_mb_lmin < 1 ||
2351 video_mb_lmin > FF_LAMBDA_MAX) {
2352 fprintf(stderr, "mblmin must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2357 static void opt_mb_lmax(const char *arg)
2359 video_mb_lmax = atof(arg)*FF_QP2LAMBDA;
2360 if (video_mb_lmax < 1 ||
2361 video_mb_lmax > FF_LAMBDA_MAX) {
2362 fprintf(stderr, "mblmax must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2367 static void opt_qdiff(const char *arg)
2369 video_qdiff = atoi(arg);
2370 if (video_qdiff < 0 ||
2372 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2377 static void opt_packet_size(const char *arg)
2379 packet_size= atoi(arg);
2382 static void opt_error_rate(const char *arg)
2384 error_rate= atoi(arg);
2387 static void opt_strict(const char *arg)
2392 static void opt_top_field_first(const char *arg)
2394 top_field_first= atoi(arg);
2397 static void opt_thread_count(const char *arg)
2399 thread_count= atoi(arg);
2400 #if !defined(HAVE_THREADS)
2402 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2406 static void opt_audio_bitrate(const char *arg)
2408 audio_bit_rate = atoi(arg) * 1000;
2411 static void opt_audio_rate(const char *arg)
2413 audio_sample_rate = atoi(arg);
2416 static void opt_audio_channels(const char *arg)
2418 audio_channels = atoi(arg);
2421 static void opt_video_device(const char *arg)
2423 video_device = av_strdup(arg);
2426 static void opt_grab_device(const char *arg)
2428 grab_device = av_strdup(arg);
2431 static void opt_video_channel(const char *arg)
2433 video_channel = strtol(arg, NULL, 0);
2436 static void opt_video_standard(const char *arg)
2438 video_standard = av_strdup(arg);
2441 static void opt_audio_device(const char *arg)
2443 audio_device = av_strdup(arg);
2446 static void opt_codec(int *pstream_copy, int *pcodec_id,
2447 int codec_type, const char *arg)
2451 if (!strcmp(arg, "copy")) {
2456 if (!strcmp(p->name, arg) && p->type == codec_type)
2461 fprintf(stderr, "Unknown codec '%s'\n", arg);
2469 static void opt_audio_codec(const char *arg)
2471 opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2474 static void opt_audio_tag(const char *arg)
2477 audio_codec_tag= strtol(arg, &tail, 0);
2480 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2483 static void opt_video_tag(const char *arg)
2486 video_codec_tag= strtol(arg, &tail, 0);
2489 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2492 static void add_frame_hooker(const char *arg)
2497 char *args = av_strdup(arg);
2501 argv[0] = strtok(args, " ");
2502 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2505 i = frame_hook_add(argc, argv);
2508 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2513 const char *motion_str[] = {
2526 static void opt_motion_estimation(const char *arg)
2532 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2535 if (!strcmp(*p, arg))
2539 me_method = (p - motion_str) + 1;
2542 static void opt_video_codec(const char *arg)
2544 opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2547 static void opt_subtitle_codec(const char *arg)
2549 opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2552 static void opt_map(const char *arg)
2558 m = &stream_maps[nb_stream_maps++];
2560 m->file_index = strtol(arg, (char **)&p, 0);
2564 m->stream_index = strtol(p, (char **)&p, 0);
2567 m->sync_file_index = strtol(p, (char **)&p, 0);
2570 m->sync_stream_index = strtol(p, (char **)&p, 0);
2572 m->sync_file_index = m->file_index;
2573 m->sync_stream_index = m->stream_index;
2577 static void opt_map_meta_data(const char *arg)
2583 m = &meta_data_maps[nb_meta_data_maps++];
2585 m->out_file = strtol(arg, (char **)&p, 0);
2589 m->in_file = strtol(p, (char **)&p, 0);
2592 static void opt_recording_time(const char *arg)
2594 recording_time = parse_date(arg, 1);
2597 static void opt_start_time(const char *arg)
2599 start_time = parse_date(arg, 1);
2602 static void opt_rec_timestamp(const char *arg)
2604 rec_timestamp = parse_date(arg, 0) / 1000000;
2607 static void opt_input_ts_offset(const char *arg)
2609 input_ts_offset = parse_date(arg, 1);
2612 static void opt_input_file(const char *filename)
2614 AVFormatContext *ic;
2615 AVFormatParameters params, *ap = ¶ms;
2616 int err, i, ret, rfps, rfps_base;
2619 if (!strcmp(filename, "-"))
2622 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2623 !strcmp( filename, "/dev/stdin" );
2625 /* get default parameters from command line */
2626 ic = av_alloc_format_context();
2628 memset(ap, 0, sizeof(*ap));
2629 ap->prealloced_context = 1;
2630 ap->sample_rate = audio_sample_rate;
2631 ap->channels = audio_channels;
2632 ap->time_base.den = frame_rate;
2633 ap->time_base.num = frame_rate_base;
2634 ap->width = frame_width + frame_padleft + frame_padright;
2635 ap->height = frame_height + frame_padtop + frame_padbottom;
2636 ap->image_format = image_format;
2637 ap->pix_fmt = frame_pix_fmt;
2638 ap->device = grab_device;
2639 ap->channel = video_channel;
2640 ap->standard = video_standard;
2641 ap->video_codec_id = video_codec_id;
2642 ap->audio_codec_id = audio_codec_id;
2643 if(pgmyuv_compatibility_hack)
2644 ap->video_codec_id= CODEC_ID_PGMYUV;
2646 for(i=0; i<opt_name_count; i++){
2648 double d= av_get_double(avformat_opts, opt_names[i], &opt);
2649 if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2650 av_set_double(ic, opt_names[i], d);
2652 /* open the input file with generic libav function */
2653 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2655 print_error(filename, err);
2659 ic->loop_input = loop_input;
2661 /* If not enough info to get the stream parameters, we decode the
2662 first frames to get it. (used in mpeg case for example) */
2663 ret = av_find_stream_info(ic);
2664 if (ret < 0 && verbose >= 0) {
2665 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2669 timestamp = start_time;
2670 /* add the stream start time */
2671 if (ic->start_time != AV_NOPTS_VALUE)
2672 timestamp += ic->start_time;
2674 /* if seeking requested, we execute it */
2675 if (start_time != 0) {
2676 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2678 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2679 filename, (double)timestamp / AV_TIME_BASE);
2681 /* reset seek info */
2685 /* update the current parameters so that they match the one of the input stream */
2686 for(i=0;i<ic->nb_streams;i++) {
2688 AVCodecContext *enc = ic->streams[i]->codec;
2689 #if defined(HAVE_THREADS)
2691 avcodec_thread_init(enc, thread_count);
2693 enc->thread_count= thread_count;
2694 switch(enc->codec_type) {
2695 case CODEC_TYPE_AUDIO:
2696 for(j=0; j<opt_name_count; j++){
2698 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2699 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2700 av_set_double(enc, opt_names[j], d);
2702 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2703 audio_channels = enc->channels;
2704 audio_sample_rate = enc->sample_rate;
2706 ic->streams[i]->discard= AVDISCARD_ALL;
2708 case CODEC_TYPE_VIDEO:
2709 for(j=0; j<opt_name_count; j++){
2711 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2712 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2713 av_set_double(enc, opt_names[j], d);
2715 frame_height = enc->height;
2716 frame_width = enc->width;
2717 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2718 frame_pix_fmt = enc->pix_fmt;
2719 rfps = ic->streams[i]->r_frame_rate.num;
2720 rfps_base = ic->streams[i]->r_frame_rate.den;
2721 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2723 enc->debug |= FF_DEBUG_MV;
2725 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2728 fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2729 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2731 (float)rfps / rfps_base, rfps, rfps_base);
2733 /* update the current frame rate to match the stream frame rate */
2735 frame_rate_base = rfps_base;
2737 enc->rate_emu = rate_emu;
2739 ic->streams[i]->discard= AVDISCARD_ALL;
2740 else if(video_discard)
2741 ic->streams[i]->discard= video_discard;
2743 case CODEC_TYPE_DATA:
2745 case CODEC_TYPE_SUBTITLE:
2747 case CODEC_TYPE_UNKNOWN:
2754 input_files[nb_input_files] = ic;
2755 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2756 /* dump the file content */
2758 dump_format(ic, nb_input_files, filename, 0);
2761 file_iformat = NULL;
2762 file_oformat = NULL;
2763 image_format = NULL;
2771 static void opt_grab(const char *arg)
2773 file_iformat = av_find_input_format(arg);
2777 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2779 int has_video, has_audio, i, j;
2780 AVFormatContext *ic;
2784 for(j=0;j<nb_input_files;j++) {
2785 ic = input_files[j];
2786 for(i=0;i<ic->nb_streams;i++) {
2787 AVCodecContext *enc = ic->streams[i]->codec;
2788 switch(enc->codec_type) {
2789 case CODEC_TYPE_AUDIO:
2792 case CODEC_TYPE_VIDEO:
2795 case CODEC_TYPE_DATA:
2796 case CODEC_TYPE_UNKNOWN:
2797 case CODEC_TYPE_SUBTITLE:
2804 *has_video_ptr = has_video;
2805 *has_audio_ptr = has_audio;
2808 static void new_video_stream(AVFormatContext *oc)
2811 AVCodecContext *video_enc;
2814 st = av_new_stream(oc, oc->nb_streams);
2816 fprintf(stderr, "Could not alloc stream\n");
2819 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2820 video_bitstream_filters= NULL;
2822 #if defined(HAVE_THREADS)
2824 avcodec_thread_init(st->codec, thread_count);
2827 video_enc = st->codec;
2830 video_enc->codec_tag= video_codec_tag;
2832 if( (video_global_header&1)
2833 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2834 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2835 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2837 if(video_global_header&2){
2838 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2839 avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2842 if (video_stream_copy) {
2843 st->stream_copy = 1;
2844 video_enc->codec_type = CODEC_TYPE_VIDEO;
2850 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2851 if (video_codec_id != CODEC_ID_NONE)
2852 codec_id = video_codec_id;
2854 video_enc->codec_id = codec_id;
2855 codec = avcodec_find_encoder(codec_id);
2857 for(i=0; i<opt_name_count; i++){
2859 double d= av_get_double(avctx_opts, opt_names[i], &opt);
2860 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2861 av_set_double(video_enc, opt_names[i], d);
2864 video_enc->time_base.den = frame_rate;
2865 video_enc->time_base.num = frame_rate_base;
2866 if(codec && codec->supported_framerates){
2867 const AVRational *p= codec->supported_framerates;
2868 AVRational req= (AVRational){frame_rate, frame_rate_base};
2869 const AVRational *best=NULL;
2870 AVRational best_error= (AVRational){INT_MAX, 1};
2871 for(; p->den!=0; p++){
2872 AVRational error= av_sub_q(req, *p);
2873 if(error.num <0) error.num *= -1;
2874 if(av_cmp_q(error, best_error) < 0){
2879 video_enc->time_base.den= best->num;
2880 video_enc->time_base.num= best->den;
2883 video_enc->width = frame_width + frame_padright + frame_padleft;
2884 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2885 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2886 video_enc->pix_fmt = frame_pix_fmt;
2888 if(codec && codec->pix_fmts){
2889 const enum PixelFormat *p= codec->pix_fmts;
2891 if(*p == video_enc->pix_fmt)
2895 video_enc->pix_fmt = codec->pix_fmts[0];
2899 video_enc->gop_size = 0;
2900 if (video_qscale || same_quality) {
2901 video_enc->flags |= CODEC_FLAG_QSCALE;
2902 video_enc->global_quality=
2903 st->quality = FF_QP2LAMBDA * video_qscale;
2907 video_enc->intra_matrix = intra_matrix;
2909 video_enc->inter_matrix = inter_matrix;
2911 video_enc->lmin = video_lmin;
2912 video_enc->lmax = video_lmax;
2913 video_enc->mb_lmin = video_mb_lmin;
2914 video_enc->mb_lmax = video_mb_lmax;
2915 video_enc->max_qdiff = video_qdiff;
2916 video_enc->rc_eq = video_rc_eq;
2917 video_enc->thread_count = thread_count;
2918 p= video_rc_override_string;
2921 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2923 fprintf(stderr, "error parsing rc_override\n");
2926 video_enc->rc_override=
2927 av_realloc(video_enc->rc_override,
2928 sizeof(RcOverride)*(i+1));
2929 video_enc->rc_override[i].start_frame= start;
2930 video_enc->rc_override[i].end_frame = end;
2932 video_enc->rc_override[i].qscale= q;
2933 video_enc->rc_override[i].quality_factor= 1.0;
2936 video_enc->rc_override[i].qscale= 0;
2937 video_enc->rc_override[i].quality_factor= -q/100.0;
2942 video_enc->rc_override_count=i;
2943 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2944 video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
2945 video_enc->me_threshold= me_threshold;
2946 video_enc->mb_threshold= mb_threshold;
2947 video_enc->intra_dc_precision= intra_dc_precision - 8;
2948 video_enc->strict_std_compliance = strict;
2949 video_enc->error_rate = error_rate;
2950 video_enc->me_penalty_compensation= me_penalty_compensation;
2951 video_enc->frame_skip_threshold= frame_skip_threshold;
2952 video_enc->frame_skip_factor= frame_skip_factor;
2953 video_enc->frame_skip_exp= frame_skip_exp;
2956 video_enc->rtp_mode= 1;
2957 video_enc->rtp_payload_size= packet_size;
2961 video_enc->flags|= CODEC_FLAG_PSNR;
2963 video_enc->me_method = me_method;
2968 video_enc->flags |= CODEC_FLAG_PASS1;
2970 video_enc->flags |= CODEC_FLAG_PASS2;
2975 /* reset some key parameters */
2977 video_codec_id = CODEC_ID_NONE;
2978 video_stream_copy = 0;
2981 static void new_audio_stream(AVFormatContext *oc)
2984 AVCodecContext *audio_enc;
2987 st = av_new_stream(oc, oc->nb_streams);
2989 fprintf(stderr, "Could not alloc stream\n");
2993 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2994 audio_bitstream_filters= NULL;
2996 #if defined(HAVE_THREADS)
2998 avcodec_thread_init(st->codec, thread_count);
3001 audio_enc = st->codec;
3002 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3005 audio_enc->codec_tag= audio_codec_tag;
3007 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3008 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3009 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
3011 if (audio_stream_copy) {
3012 st->stream_copy = 1;
3013 audio_enc->channels = audio_channels;
3015 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3017 for(i=0; i<opt_name_count; i++){
3019 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3020 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3021 av_set_double(audio_enc, opt_names[i], d);
3024 if (audio_codec_id != CODEC_ID_NONE)
3025 codec_id = audio_codec_id;
3026 audio_enc->codec_id = codec_id;
3028 audio_enc->bit_rate = audio_bit_rate;
3029 if (audio_qscale > QSCALE_NONE) {
3030 audio_enc->flags |= CODEC_FLAG_QSCALE;
3031 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3033 audio_enc->strict_std_compliance = strict;
3034 audio_enc->thread_count = thread_count;
3035 /* For audio codecs other than AC3 or DTS we limit */
3036 /* the number of coded channels to stereo */
3037 if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3038 && codec_id != CODEC_ID_DTS) {
3039 audio_enc->channels = 2;
3041 audio_enc->channels = audio_channels;
3043 audio_enc->sample_rate = audio_sample_rate;
3044 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3045 if (audio_language) {
3046 pstrcpy(st->language, sizeof(st->language), audio_language);
3047 av_free(audio_language);
3048 audio_language = NULL;
3051 /* reset some key parameters */
3053 audio_codec_id = CODEC_ID_NONE;
3054 audio_stream_copy = 0;
3057 static void opt_new_subtitle_stream(void)
3059 AVFormatContext *oc;
3061 AVCodecContext *subtitle_enc;
3064 if (nb_output_files <= 0) {
3065 fprintf(stderr, "At least one output file must be specified\n");
3068 oc = output_files[nb_output_files - 1];
3070 st = av_new_stream(oc, oc->nb_streams);
3072 fprintf(stderr, "Could not alloc stream\n");
3076 subtitle_enc = st->codec;
3077 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3078 if (subtitle_stream_copy) {
3079 st->stream_copy = 1;
3081 for(i=0; i<opt_name_count; i++){
3083 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3084 if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3085 av_set_double(subtitle_enc, opt_names[i], d);
3087 subtitle_enc->codec_id = subtitle_codec_id;
3090 if (subtitle_language) {
3091 pstrcpy(st->language, sizeof(st->language), subtitle_language);
3092 av_free(subtitle_language);
3093 subtitle_language = NULL;
3096 subtitle_codec_id = CODEC_ID_NONE;
3097 subtitle_stream_copy = 0;
3100 static void opt_new_audio_stream(void)
3102 AVFormatContext *oc;
3103 if (nb_output_files <= 0) {
3104 fprintf(stderr, "At least one output file must be specified\n");
3107 oc = output_files[nb_output_files - 1];
3108 new_audio_stream(oc);
3111 static void opt_new_video_stream(void)
3113 AVFormatContext *oc;
3114 if (nb_output_files <= 0) {
3115 fprintf(stderr, "At least one output file must be specified\n");
3118 oc = output_files[nb_output_files - 1];
3119 new_video_stream(oc);
3122 static void opt_output_file(const char *filename)
3124 AVFormatContext *oc;
3125 int use_video, use_audio, input_has_video, input_has_audio, i;
3126 AVFormatParameters params, *ap = ¶ms;
3128 if (!strcmp(filename, "-"))
3131 oc = av_alloc_format_context();
3133 if (!file_oformat) {
3134 file_oformat = guess_format(NULL, filename, NULL);
3135 if (!file_oformat) {
3136 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3142 oc->oformat = file_oformat;
3143 pstrcpy(oc->filename, sizeof(oc->filename), filename);
3145 if (!strcmp(file_oformat->name, "ffm") &&
3146 strstart(filename, "http:", NULL)) {
3147 /* special case for files sent to ffserver: we get the stream
3148 parameters from ffserver */
3149 if (read_ffserver_streams(oc, filename) < 0) {
3150 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3154 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3155 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3157 /* disable if no corresponding type found and at least one
3159 if (nb_input_files > 0) {
3160 check_audio_video_inputs(&input_has_video, &input_has_audio);
3161 if (!input_has_video)
3163 if (!input_has_audio)
3167 /* manual disable */
3168 if (audio_disable) {
3171 if (video_disable) {
3176 new_video_stream(oc);
3180 new_audio_stream(oc);
3183 if (!oc->nb_streams) {
3184 fprintf(stderr, "No audio or video streams available\n");
3188 oc->timestamp = rec_timestamp;
3191 pstrcpy(oc->title, sizeof(oc->title), str_title);
3193 pstrcpy(oc->author, sizeof(oc->author), str_author);
3195 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3197 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3199 pstrcpy(oc->album, sizeof(oc->album), str_album);
3202 output_files[nb_output_files++] = oc;
3204 /* check filename in case of an image number is expected */
3205 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3206 if (!av_filename_number_test(oc->filename)) {
3207 print_error(oc->filename, AVERROR_NUMEXPECTED);
3212 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3213 /* test if it already exists to avoid loosing precious files */
3214 if (!file_overwrite &&
3215 (strchr(filename, ':') == NULL ||
3216 strstart(filename, "file:", NULL))) {
3217 if (url_exist(filename)) {
3220 if ( !using_stdin ) {
3221 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3224 if (toupper(c) != 'Y') {
3225 fprintf(stderr, "Not overwriting - exiting\n");
3230 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3237 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3238 fprintf(stderr, "Could not open '%s'\n", filename);
3243 memset(ap, 0, sizeof(*ap));
3244 ap->image_format = image_format;
3245 if (av_set_parameters(oc, ap) < 0) {
3246 fprintf(stderr, "%s: Invalid encoding parameters\n",
3251 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3252 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3253 oc->loop_output = loop_output;
3255 for(i=0; i<opt_name_count; i++){
3257 double d = av_get_double(avformat_opts, opt_names[i], &opt);
3258 if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3259 av_set_double(oc, opt_names[i], d);
3262 /* reset some options */
3263 file_oformat = NULL;
3264 file_iformat = NULL;
3265 image_format = NULL;
3268 /* prepare dummy protocols for grab */
3269 static void prepare_grab(void)
3271 int has_video, has_audio, i, j;
3272 AVFormatContext *oc;
3273 AVFormatContext *ic;
3274 AVFormatParameters vp1, *vp = &vp1;
3275 AVFormatParameters ap1, *ap = &ap1;
3277 /* see if audio/video inputs are needed */
3280 memset(ap, 0, sizeof(*ap));
3281 memset(vp, 0, sizeof(*vp));
3282 vp->time_base.num= 1;
3283 for(j=0;j<nb_output_files;j++) {
3284 oc = output_files[j];
3285 for(i=0;i<oc->nb_streams;i++) {
3286 AVCodecContext *enc = oc->streams[i]->codec;
3287 switch(enc->codec_type) {
3288 case CODEC_TYPE_AUDIO:
3289 if (enc->sample_rate > ap->sample_rate)
3290 ap->sample_rate = enc->sample_rate;
3291 if (enc->channels > ap->channels)
3292 ap->channels = enc->channels;
3295 case CODEC_TYPE_VIDEO:
3296 if (enc->width > vp->width)
3297 vp->width = enc->width;
3298 if (enc->height > vp->height)
3299 vp->height = enc->height;
3301 if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3302 vp->time_base = enc->time_base;
3303 vp->width += frame_leftBand + frame_rightBand;
3304 vp->width -= (frame_padleft + frame_padright);
3305 vp->height += frame_topBand + frame_bottomBand;
3306 vp->height -= (frame_padtop + frame_padbottom);
3316 if (has_video == 0 && has_audio == 0) {
3317 fprintf(stderr, "Output file must have at least one audio or video stream\n");
3322 AVInputFormat *fmt1;
3323 fmt1 = av_find_input_format(video_grab_format);
3324 vp->device = video_device;
3325 vp->channel = video_channel;
3326 vp->standard = video_standard;
3327 vp->pix_fmt = frame_pix_fmt;
3328 if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3329 fprintf(stderr, "Could not find video grab device\n");
3332 /* If not enough info to get the stream parameters, we decode the
3333 first frames to get it. */
3334 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3335 fprintf(stderr, "Could not find video grab parameters\n");
3338 /* by now video grab has one stream */
3339 ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3340 ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3341 input_files[nb_input_files] = ic;
3344 dump_format(ic, nb_input_files, "", 0);
3348 if (has_audio && audio_grab_format) {
3349 AVInputFormat *fmt1;
3350 fmt1 = av_find_input_format(audio_grab_format);
3351 ap->device = audio_device;
3352 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3353 fprintf(stderr, "Could not find audio grab device\n");
3356 input_files[nb_input_files] = ic;
3359 dump_format(ic, nb_input_files, "", 0);
3365 /* same option as mencoder */
3366 static void opt_pass(const char *pass_str)
3369 pass = atoi(pass_str);
3370 if (pass != 1 && pass != 2) {
3371 fprintf(stderr, "pass number can be only 1 or 2\n");
3377 #if defined(__MINGW32__) || defined(CONFIG_OS2)
3378 static int64_t getutime(void)
3380 return av_gettime();
3383 static int64_t getutime(void)
3385 struct rusage rusage;
3387 getrusage(RUSAGE_SELF, &rusage);
3388 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3392 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3393 extern int ffm_nopts;
3396 static void show_formats(void)
3398 AVInputFormat *ifmt;
3399 AVOutputFormat *ofmt;
3400 AVImageFormat *image_fmt;
3403 const char **pp, *last_name;
3405 printf("File formats:\n");
3410 const char *name=NULL;
3411 const char *long_name=NULL;
3413 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3414 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3415 strcmp(ofmt->name, last_name)>0){
3417 long_name= ofmt->long_name;
3421 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3422 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3423 strcmp(ifmt->name, last_name)>0){
3425 long_name= ifmt->long_name;
3428 if(name && strcmp(ifmt->name, name)==0)
3440 long_name ? long_name:" ");
3444 printf("Image formats (filename extensions, if any, follow):\n");
3445 for(image_fmt = first_image_format; image_fmt != NULL;
3446 image_fmt = image_fmt->next) {
3449 image_fmt->img_read ? "D":" ",
3450 image_fmt->img_write ? "E":" ",
3452 image_fmt->extensions ? image_fmt->extensions:" ");
3456 printf("Codecs:\n");
3462 const char *type_str;
3465 for(p = first_avcodec; p != NULL; p = p->next) {
3466 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3467 strcmp(p->name, last_name)>0){
3469 decode= encode= cap=0;
3471 if(p2 && strcmp(p->name, p2->name)==0){
3472 if(p->decode) decode=1;
3473 if(p->encode) encode=1;
3474 cap |= p->capabilities;
3479 last_name= p2->name;
3482 case CODEC_TYPE_VIDEO:
3485 case CODEC_TYPE_AUDIO:
3488 case CODEC_TYPE_SUBTITLE:
3497 decode ? "D": (/*p2->decoder ? "d":*/" "),
3500 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3501 cap & CODEC_CAP_DR1 ? "D":" ",
3502 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3504 /* if(p2->decoder && decode==0)
3505 printf(" use %s for decoding", p2->decoder->name);*/
3510 printf("Supported file protocols:\n");
3511 for(up = first_protocol; up != NULL; up = up->next)
3512 printf(" %s:", up->name);
3515 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3516 printf("Motion estimation methods:\n");
3520 if ((pp - motion_str + 1) == ME_ZERO)
3521 printf("(fastest)");
3522 else if ((pp - motion_str + 1) == ME_FULL)
3523 printf("(slowest)");
3524 else if ((pp - motion_str + 1) == ME_EPZS)
3525 printf("(default)");
3530 "Note, the names of encoders and decoders dont always match, so there are\n"
3531 "several cases where the above table shows encoder only or decoder only entries\n"
3532 "even though both encoding and decoding are supported for example, the h263\n"
3533 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3538 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3541 const char *p = str;
3548 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3555 static void opt_inter_matrix(const char *arg)
3557 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3558 parse_matrix_coeffs(inter_matrix, arg);
3561 static void opt_intra_matrix(const char *arg)
3563 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3564 parse_matrix_coeffs(intra_matrix, arg);
3567 static void opt_target(const char *arg)
3570 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3572 if(!strncmp(arg, "pal-", 4)) {
3575 } else if(!strncmp(arg, "ntsc-", 5)) {
3578 } else if(!strncmp(arg, "film-", 5)) {
3583 /* Calculate FR via float to avoid int overflow */
3584 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3587 } else if((fr == 29970) || (fr == 23976)) {
3590 /* Try to determine PAL/NTSC by peeking in the input files */
3591 if(nb_input_files) {
3593 for(j = 0; j < nb_input_files; j++) {
3594 for(i = 0; i < input_files[j]->nb_streams; i++) {
3595 AVCodecContext *c = input_files[j]->streams[i]->codec;
3596 if(c->codec_type != CODEC_TYPE_VIDEO)
3598 fr = c->time_base.den * 1000 / c->time_base.num;
3602 } else if((fr == 29970) || (fr == 23976)) {
3612 if(verbose && norm >= 0)
3613 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3617 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3618 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3619 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3623 if(!strcmp(arg, "vcd")) {
3625 opt_video_codec("mpeg1video");
3626 opt_audio_codec("mp2");
3629 opt_frame_size(norm ? "352x240" : "352x288");
3630 opt_frame_rate(frame_rates[norm]);
3631 opt_default("gop", norm ? "18" : "15");
3633 opt_default("b", "1150000");
3634 opt_default("maxrate", "1150000");
3635 opt_default("minrate", "1150000");
3636 opt_default("bufsize", "327680"); // 40*1024*8;
3638 audio_bit_rate = 224000;
3639 audio_sample_rate = 44100;
3641 opt_default("packetsize", "2324");
3642 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3644 /* We have to offset the PTS, so that it is consistent with the SCR.
3645 SCR starts at 36000, but the first two packs contain only padding
3646 and the first pack from the other stream, respectively, may also have
3647 been written before.
3648 So the real data starts at SCR 36000+3*1200. */
3649 mux_preload= (36000+3*1200) / 90000.0; //0.44
3650 } else if(!strcmp(arg, "svcd")) {
3652 opt_video_codec("mpeg2video");
3653 opt_audio_codec("mp2");
3656 opt_frame_size(norm ? "480x480" : "480x576");
3657 opt_frame_rate(frame_rates[norm]);
3658 opt_default("gop", norm ? "18" : "15");
3660 opt_default("b", "2040000");
3661 opt_default("maxrate", "2516000");
3662 opt_default("minrate", "0"); //1145000;
3663 opt_default("bufsize", "1835008"); //224*1024*8;
3664 opt_default("flags", "+SCAN_OFFSET");
3667 audio_bit_rate = 224000;
3668 audio_sample_rate = 44100;
3670 opt_default("packetsize", "2324");
3672 } else if(!strcmp(arg, "dvd")) {
3674 opt_video_codec("mpeg2video");
3675 opt_audio_codec("ac3");
3678 opt_frame_size(norm ? "720x480" : "720x576");
3679 opt_frame_rate(frame_rates[norm]);
3680 opt_default("gop", norm ? "18" : "15");
3682 opt_default("b", "6000000");
3683 opt_default("maxrate", "9000000");
3684 opt_default("minrate", "0"); //1500000;
3685 opt_default("bufsize", "1835008"); //224*1024*8;
3687 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3688 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3690 audio_bit_rate = 448000;
3691 audio_sample_rate = 48000;
3693 } else if(!strncmp(arg, "dv", 2)) {
3697 opt_frame_size(norm ? "720x480" : "720x576");
3698 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3699 (norm ? "yuv411p" : "yuv420p"));
3700 opt_frame_rate(frame_rates[norm]);
3702 audio_sample_rate = 48000;
3706 fprintf(stderr, "Unknown target: %s\n", arg);
3711 static void opt_video_bsf(const char *arg)
3713 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3714 AVBitStreamFilterContext **bsfp;
3717 fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3721 bsfp= &video_bitstream_filters;
3723 bsfp= &(*bsfp)->next;
3728 //FIXME avoid audio - video code duplication
3729 static void opt_audio_bsf(const char *arg)
3731 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3732 AVBitStreamFilterContext **bsfp;
3735 fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3739 bsfp= &audio_bitstream_filters;
3741 bsfp= &(*bsfp)->next;
3746 static void show_version(void)
3748 /* TODO: add function interface to avutil and avformat */
3749 fprintf(stderr, "ffmpeg " FFMPEG_VERSION "\n"
3753 LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3757 static int opt_default(const char *opt, const char *arg){
3758 AVOption *o= av_set_string(avctx_opts, opt, arg);
3760 o = av_set_string(avformat_opts, opt, arg);
3764 // av_log(NULL, AV_LOG_ERROR, "%s:%s: %f 0x%0X\n", opt, arg, av_get_double(avctx_opts, opt, NULL), (int)av_get_int(avctx_opts, opt, NULL));
3766 //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3767 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3768 opt_names[opt_name_count++]= o->name;
3770 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3771 /* disable generate of real time pts in ffm (need to be supressed anyway) */
3772 if(avctx_opts->flags & CODEC_FLAG_BITEXACT)
3776 if(avctx_opts->debug)
3777 av_log_set_level(AV_LOG_DEBUG);
3781 const OptionDef options[] = {
3783 { "L", 0, {(void*)show_license}, "show license" },
3784 { "h", 0, {(void*)show_help}, "show help" },
3785 { "version", 0, {(void*)show_version}, "show version" },
3786 { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3787 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3788 { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3789 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3790 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3791 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3792 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3793 { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3794 { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
3795 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3796 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3797 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3798 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3799 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3800 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3801 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3802 { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3803 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3804 "add timings for benchmarking" },
3805 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3806 "dump each input packet" },
3807 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3808 "when dumping packets, also dump the payload" },
3809 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3810 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3811 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "number of times to loop output in formats that support looping (0 loops forever)", "" },
3812 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3813 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3814 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3815 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3816 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3817 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3818 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3819 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3820 { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3823 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3824 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3825 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3826 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3827 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3828 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3829 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3830 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3831 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3832 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3833 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3834 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3835 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3836 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3837 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3838 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3839 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3840 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3841 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3842 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
3843 { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
3844 { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
3845 { "mblmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmin}, "min macroblock quantiser scale (VBR)", "q" },
3846 { "mblmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmax}, "max macroblock quantiser scale (VBR)", "q" },
3847 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
3848 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3849 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3850 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3851 { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3853 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
3854 { "mb_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_threshold}, "macroblock threshold", "" },
3855 { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
3856 { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
3857 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3858 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3859 "use same video quality as source (implies VBR)" },
3860 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3861 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3862 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3863 "deinterlace pictures" },
3864 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3865 { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
3866 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3867 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3868 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3869 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3870 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3871 { "mepc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&me_penalty_compensation}, "motion estimation bitrate penalty compensation", "factor (1.0 = 256)" },
3872 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3873 { "skip_threshold", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_threshold}, "frame skip threshold", "threshold" },
3874 { "skip_factor", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_factor}, "frame skip factor", "factor" },
3875 { "skip_exp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_exp}, "frame skip exponent", "exponent" },
3876 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3877 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3880 { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
3881 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3882 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3883 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3884 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3885 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3886 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3887 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3888 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3889 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3891 /* subtitle options */
3892 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3893 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3894 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3897 { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
3898 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3899 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3900 { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
3902 /* G.2 grab options */
3903 { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
3904 { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
3907 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3908 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3910 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
3911 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
3913 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3917 static void show_banner(void)
3919 fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2004 Fabrice Bellard\n");
3920 fprintf(stderr, " configuration: " FFMPEG_CONFIGURATION "\n");
3921 fprintf(stderr, " libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
3922 fprintf(stderr, " libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
3923 fprintf(stderr, " libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
3924 fprintf(stderr, " built on " __DATE__ " " __TIME__);
3926 fprintf(stderr, ", gcc: " __VERSION__ "\n");
3928 fprintf(stderr, ", using a non-gcc compiler\n");
3932 static void show_license(void)
3937 "This program is free software; you can redistribute it and/or modify\n"
3938 "it under the terms of the GNU General Public License as published by\n"
3939 "the Free Software Foundation; either version 2 of the License, or\n"
3940 "(at your option) any later version.\n"
3942 "This program is distributed in the hope that it will be useful,\n"
3943 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3944 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
3945 "GNU General Public License for more details.\n"
3947 "You should have received a copy of the GNU General Public License\n"
3948 "along with this program; if not, write to the Free Software\n"
3949 "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
3953 "This library is free software; you can redistribute it and/or\n"
3954 "modify it under the terms of the GNU Lesser General Public\n"
3955 "License as published by the Free Software Foundation; either\n"
3956 "version 2 of the License, or (at your option) any later version.\n"
3958 "This library is distributed in the hope that it will be useful,\n"
3959 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3960 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
3961 "Lesser General Public License for more details.\n"
3963 "You should have received a copy of the GNU Lesser General Public\n"
3964 "License along with this library; if not, write to the Free Software\n"
3965 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
3971 static void show_help(void)
3974 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3975 "Hyper fast Audio and Video encoder\n");
3977 show_help_options(options, "Main options:\n",
3978 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3979 show_help_options(options, "\nVideo options:\n",
3980 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3982 show_help_options(options, "\nAdvanced Video options:\n",
3983 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3984 OPT_VIDEO | OPT_EXPERT);
3985 show_help_options(options, "\nAudio options:\n",
3986 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3988 show_help_options(options, "\nAdvanced Audio options:\n",
3989 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3990 OPT_AUDIO | OPT_EXPERT);
3991 show_help_options(options, "\nSubtitle options:\n",
3992 OPT_SUBTITLE | OPT_GRAB,
3994 show_help_options(options, "\nAudio/Video grab options:\n",
3997 show_help_options(options, "\nAdvanced options:\n",
3998 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4000 av_opt_show(avctx_opts, NULL);
4001 av_opt_show(avformat_opts, NULL);
4006 void parse_arg_file(const char *filename)
4008 opt_output_file(filename);
4011 int main(int argc, char **argv)
4018 avctx_opts= avcodec_alloc_context();
4019 avformat_opts = av_alloc_format_context();
4027 parse_options(argc, argv, options);
4029 /* file converter / grab */
4030 if (nb_output_files <= 0) {
4031 fprintf(stderr, "Must supply at least one output file\n");
4035 if (nb_input_files == 0) {
4041 av_encode(output_files, nb_output_files, input_files, nb_input_files,
4042 stream_maps, nb_stream_maps);
4043 ti = getutime() - ti;
4045 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4049 for(i=0;i<nb_output_files;i++) {
4050 /* maybe av_close_output_file ??? */
4051 AVFormatContext *s = output_files[i];
4053 if (!(s->oformat->flags & AVFMT_NOFILE))
4055 for(j=0;j<s->nb_streams;j++)
4056 av_free(s->streams[j]);
4059 for(i=0;i<nb_input_files;i++)
4060 av_close_input_file(input_files[i]);
4065 av_free(intra_matrix);
4067 av_free(inter_matrix);
4069 #ifdef POWERPC_PERFORMANCE_REPORT
4070 extern void powerpc_display_perf_report(void);
4071 powerpc_display_perf_report();
4072 #endif /* POWERPC_PERFORMANCE_REPORT */
4075 if (received_sigterm) {
4077 "Received signal %d: terminating.\n",
4078 (int) received_sigterm);
4082 exit(0); /* not all OS-es handle main() return value */