3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 #define HAVE_AV_CONFIG_H
23 #include "framehook.h"
31 #include <sys/ioctl.h>
34 #include <sys/resource.h>
38 #include <sys/types.h>
39 #include <sys/select.h>
42 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
51 #if !defined(INFINITY) && defined(HUGE_VAL)
52 #define INFINITY HUGE_VAL
55 /* select an input stream for an output stream */
56 typedef struct AVStreamMap {
60 int sync_stream_index;
63 /** select an input file for an output file */
64 typedef struct AVMetaDataMap {
69 extern const OptionDef options[];
71 static void show_help(void);
72 static void show_license(void);
73 static int opt_default(const char *opt, const char *arg);
77 static AVFormatContext *input_files[MAX_FILES];
78 static int64_t input_files_ts_offset[MAX_FILES];
79 static int nb_input_files = 0;
81 static AVFormatContext *output_files[MAX_FILES];
82 static int nb_output_files = 0;
84 static AVStreamMap stream_maps[MAX_FILES];
85 static int nb_stream_maps;
87 static AVMetaDataMap meta_data_maps[MAX_FILES];
88 static int nb_meta_data_maps;
90 static AVInputFormat *file_iformat;
91 static AVOutputFormat *file_oformat;
92 static AVImageFormat *image_format;
93 static int frame_width = 0;
94 static int frame_height = 0;
95 static float frame_aspect_ratio = 0;
96 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
97 static int frame_padtop = 0;
98 static int frame_padbottom = 0;
99 static int frame_padleft = 0;
100 static int frame_padright = 0;
101 static int padcolor[3] = {16,128,128}; /* default to black */
102 static int frame_topBand = 0;
103 static int frame_bottomBand = 0;
104 static int frame_leftBand = 0;
105 static int frame_rightBand = 0;
106 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
107 static int frame_rate = 25;
108 static int frame_rate_base = 1;
109 static float video_qscale = 0;
110 static int video_qdiff = 3;
111 static uint16_t *intra_matrix = NULL;
112 static uint16_t *inter_matrix = NULL;
113 #if 0 //experimental, (can be removed)
114 static float video_rc_qsquish=1.0;
115 static float video_rc_qmod_amp=0;
116 static int video_rc_qmod_freq=0;
118 static char *video_rc_override_string=NULL;
119 static char *video_rc_eq="tex^qComp";
120 static int me_method = ME_EPZS;
121 static int video_disable = 0;
122 static int video_discard = 0;
123 static int video_codec_id = CODEC_ID_NONE;
124 static int video_codec_tag = 0;
125 static int same_quality = 0;
126 static int do_deinterlace = 0;
127 static int packet_size = 0;
128 static int strict = 0;
129 static int top_field_first = -1;
130 static int me_threshold = 0;
131 static int intra_dc_precision = 8;
132 static int loop_input = 0;
133 static int loop_output = AVFMT_NOOUTPUTLOOP;
134 static int qp_hist = 0;
136 static int intra_only = 0;
137 static int audio_sample_rate = 44100;
138 static int audio_bit_rate = 64000;
139 #define QSCALE_NONE -99999
140 static float audio_qscale = QSCALE_NONE;
141 static int audio_disable = 0;
142 static int audio_channels = 1;
143 static int audio_codec_id = CODEC_ID_NONE;
144 static int audio_codec_tag = 0;
145 static char *audio_language = NULL;
147 static int subtitle_codec_id = CODEC_ID_NONE;
148 static char *subtitle_language = NULL;
150 static float mux_preload= 0.5;
151 static float mux_max_delay= 0.7;
153 static int64_t recording_time = 0;
154 static int64_t start_time = 0;
155 static int64_t rec_timestamp = 0;
156 static int64_t input_ts_offset = 0;
157 static int file_overwrite = 0;
158 static char *str_title = NULL;
159 static char *str_author = NULL;
160 static char *str_copyright = NULL;
161 static char *str_comment = NULL;
162 static char *str_album = NULL;
163 static int do_benchmark = 0;
164 static int do_hex_dump = 0;
165 static int do_pkt_dump = 0;
166 static int do_psnr = 0;
167 static int do_vstats = 0;
168 static int do_pass = 0;
169 static char *pass_logfilename = NULL;
170 static int audio_stream_copy = 0;
171 static int video_stream_copy = 0;
172 static int subtitle_stream_copy = 0;
173 static int video_sync_method= 1;
174 static int audio_sync_method= 0;
175 static int copy_ts= 0;
176 static int opt_shortest = 0; //
177 static int video_global_header = 0;
179 static int rate_emu = 0;
182 static const char *video_grab_format = "bktr";
184 #ifdef CONFIG_VIDEO4LINUX2
185 static const char *video_grab_format = "video4linux2";
187 static const char *video_grab_format = "video4linux";
190 static char *video_device = NULL;
191 static char *grab_device = NULL;
192 static int video_channel = 0;
193 static char *video_standard = "ntsc";
195 static const char *audio_grab_format = "audio_device";
196 static char *audio_device = NULL;
197 static int audio_volume = 256;
199 static int using_stdin = 0;
200 static int using_vhook = 0;
201 static int verbose = 1;
202 static int thread_count= 1;
203 static int q_pressed = 0;
204 static int64_t video_size = 0;
205 static int64_t audio_size = 0;
206 static int64_t extra_size = 0;
207 static int nb_frames_dup = 0;
208 static int nb_frames_drop = 0;
209 static int input_sync;
210 static int limit_filesize = 0; //
212 static int pgmyuv_compatibility_hack=0;
213 static int dts_delta_threshold = 10;
215 static int sws_flags = SWS_BICUBIC;
217 const char **opt_names=NULL;
218 int opt_name_count=0;
219 AVCodecContext *avctx_opts;
220 AVFormatContext *avformat_opts;
222 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
223 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
224 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
226 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
228 struct AVInputStream;
230 typedef struct AVOutputStream {
231 int file_index; /* file index */
232 int index; /* stream index in the output file */
233 int source_index; /* AVInputStream index */
234 AVStream *st; /* stream in the output file */
235 int encoding_needed; /* true if encoding needed for this stream */
237 /* input pts and corresponding output pts
239 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
240 struct AVInputStream *sync_ist; /* input stream to sync against */
241 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
244 AVFrame pict_tmp; /* temporary image for resampling */
245 struct SwsContext *img_resample_ctx; /* for image resampling */
249 int topBand; /* cropping area sizes */
253 int padtop; /* padding area sizes */
260 ReSampleContext *resample; /* for audio resampling */
261 AVFifoBuffer fifo; /* for compression: one audio fifo per codec */
265 typedef struct AVInputStream {
269 int discard; /* true if stream data should be discarded */
270 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
271 int64_t sample_index; /* current sample */
273 int64_t start; /* time when read started */
274 unsigned long frame; /* current frame */
275 int64_t next_pts; /* synthetic pts for cases where pkt.pts
277 int64_t pts; /* current pts */
278 int is_start; /* is 1 at the start and after a discontinuity */
281 typedef struct AVInputFile {
282 int eof_reached; /* true if eof reached */
283 int ist_index; /* index of first stream in ist_table */
284 int buffer_size; /* current total buffer size */
285 int buffer_size_max; /* buffer size at which we consider we can stop
287 int nb_streams; /* nb streams we are aware of */
292 /* init terminal so that we can grab keys */
293 static struct termios oldtty;
295 static void term_exit(void)
297 tcsetattr (0, TCSANOW, &oldtty);
300 static volatile sig_atomic_t received_sigterm = 0;
303 sigterm_handler(int sig)
305 received_sigterm = sig;
309 static void term_init(void)
316 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
317 |INLCR|IGNCR|ICRNL|IXON);
318 tty.c_oflag |= OPOST;
319 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
320 tty.c_cflag &= ~(CSIZE|PARENB);
325 tcsetattr (0, TCSANOW, &tty);
327 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
328 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
329 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
331 register a function to be called at normal program termination
334 #ifdef CONFIG_BEOS_NETSERVER
335 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
339 /* read a key without blocking */
340 static int read_key(void)
344 #ifndef CONFIG_BEOS_NETSERVER
352 n = select(1, &rfds, NULL, NULL, &tv);
364 static int decode_interrupt_cb(void)
366 return q_pressed || (q_pressed = read_key() == 'q');
371 static volatile int received_sigterm = 0;
373 /* no interactive support */
374 static void term_exit(void)
378 static void term_init(void)
382 static int read_key(void)
389 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
394 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
397 /* copy stream format */
398 s->nb_streams = ic->nb_streams;
399 for(i=0;i<ic->nb_streams;i++) {
402 // FIXME: a more elegant solution is needed
403 st = av_mallocz(sizeof(AVStream));
404 memcpy(st, ic->streams[i], sizeof(AVStream));
405 st->codec = avcodec_alloc_context();
406 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
410 av_close_input_file(ic);
415 get_sync_ipts(const AVOutputStream *ost)
417 const AVInputStream *ist = ost->sync_ist;
418 return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
421 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
423 AVPacket new_pkt= *pkt;
424 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
425 &new_pkt.data, &new_pkt.size,
426 pkt->data, pkt->size,
427 pkt->flags & PKT_FLAG_KEY);
430 new_pkt.destruct= av_destruct_packet;
437 av_interleaved_write_frame(s, pkt);
440 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
442 static void do_audio_out(AVFormatContext *s,
445 unsigned char *buf, int size)
448 static uint8_t *audio_buf = NULL;
449 static uint8_t *audio_out = NULL;
450 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
452 int size_out, frame_bytes, ret;
453 AVCodecContext *enc= ost->st->codec;
455 /* SC: dynamic allocation of buffers */
457 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
459 audio_out = av_malloc(audio_out_size);
460 if (!audio_buf || !audio_out)
461 return; /* Should signal an error ! */
463 if(audio_sync_method){
464 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
465 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
466 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
467 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
469 //FIXME resample delay
470 if(fabs(delta) > 50){
473 byte_delta= FFMAX(byte_delta, -size);
477 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
482 static uint8_t *input_tmp= NULL;
483 input_tmp= av_realloc(input_tmp, byte_delta + size);
485 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
488 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
490 memset(input_tmp, 0, byte_delta);
491 memcpy(input_tmp + byte_delta, buf, size);
495 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
497 }else if(audio_sync_method>1){
498 int comp= clip(delta, -audio_sync_method, audio_sync_method);
499 assert(ost->audio_resample);
501 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
502 // fprintf(stderr, "drift:%f len:%d opts:%lld ipts:%lld fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2));
503 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
507 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
508 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
510 if (ost->audio_resample) {
512 size_out = audio_resample(ost->resample,
513 (short *)buftmp, (short *)buf,
514 size / (ist->st->codec->channels * 2));
515 size_out = size_out * enc->channels * 2;
521 /* now encode as many frames as possible */
522 if (enc->frame_size > 1) {
523 /* output resampled raw samples */
524 av_fifo_write(&ost->fifo, buftmp, size_out);
526 frame_bytes = enc->frame_size * 2 * enc->channels;
528 while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
530 av_init_packet(&pkt);
532 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
535 pkt.stream_index= ost->index;
538 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
539 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
540 pkt.flags |= PKT_FLAG_KEY;
541 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
543 ost->sync_opts += enc->frame_size;
547 av_init_packet(&pkt);
549 ost->sync_opts += size_out / (2 * enc->channels);
551 /* output a pcm frame */
552 /* XXX: change encoding codec API to avoid this ? */
553 switch(enc->codec->id) {
554 case CODEC_ID_PCM_S32LE:
555 case CODEC_ID_PCM_S32BE:
556 case CODEC_ID_PCM_U32LE:
557 case CODEC_ID_PCM_U32BE:
558 size_out = size_out << 1;
560 case CODEC_ID_PCM_S24LE:
561 case CODEC_ID_PCM_S24BE:
562 case CODEC_ID_PCM_U24LE:
563 case CODEC_ID_PCM_U24BE:
564 case CODEC_ID_PCM_S24DAUD:
565 size_out = size_out / 2 * 3;
567 case CODEC_ID_PCM_S16LE:
568 case CODEC_ID_PCM_S16BE:
569 case CODEC_ID_PCM_U16LE:
570 case CODEC_ID_PCM_U16BE:
573 size_out = size_out >> 1;
576 ret = avcodec_encode_audio(enc, audio_out, size_out,
579 pkt.stream_index= ost->index;
582 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
583 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
584 pkt.flags |= PKT_FLAG_KEY;
585 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
589 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
593 AVPicture picture_tmp;
596 dec = ist->st->codec;
598 /* deinterlace : must be done before any resize */
599 if (do_deinterlace || using_vhook) {
602 /* create temporary picture */
603 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
604 buf = av_malloc(size);
608 picture2 = &picture_tmp;
609 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
612 if(avpicture_deinterlace(picture2, picture,
613 dec->pix_fmt, dec->width, dec->height) < 0) {
614 /* if error, do not deinterlace */
620 img_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
626 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
628 if (picture != picture2)
629 *picture = *picture2;
633 /* we begin to correct av delay at this threshold */
634 #define AV_DELAY_MAX 0.100
636 static void do_subtitle_out(AVFormatContext *s,
642 static uint8_t *subtitle_out = NULL;
643 int subtitle_out_max_size = 65536;
644 int subtitle_out_size, nb, i;
648 if (pts == AV_NOPTS_VALUE) {
649 fprintf(stderr, "Subtitle packets must have a pts\n");
653 enc = ost->st->codec;
656 subtitle_out = av_malloc(subtitle_out_max_size);
659 /* Note: DVB subtitle need one packet to draw them and one other
660 packet to clear them */
661 /* XXX: signal it in the codec context ? */
662 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
667 for(i = 0; i < nb; i++) {
668 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
669 subtitle_out_max_size, sub);
671 av_init_packet(&pkt);
672 pkt.stream_index = ost->index;
673 pkt.data = subtitle_out;
674 pkt.size = subtitle_out_size;
675 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);
676 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
677 /* XXX: the pts correction is handled here. Maybe handling
678 it in the codec would be better */
680 pkt.pts += 90 * sub->start_display_time;
682 pkt.pts += 90 * sub->end_display_time;
684 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
688 static int bit_buffer_size= 1024*256;
689 static uint8_t *bit_buffer= NULL;
691 static void do_video_out(AVFormatContext *s,
697 int nb_frames, i, ret;
698 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
699 AVFrame picture_crop_temp, picture_pad_temp;
700 uint8_t *buf = NULL, *buf1 = NULL;
701 AVCodecContext *enc, *dec;
703 avcodec_get_frame_defaults(&picture_crop_temp);
704 avcodec_get_frame_defaults(&picture_pad_temp);
706 enc = ost->st->codec;
707 dec = ist->st->codec;
709 /* by default, we output a single frame */
714 if(video_sync_method){
716 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
717 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
720 else if (vdelta > 1.1)
721 nb_frames = lrintf(vdelta);
722 //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);
726 fprintf(stderr, "*** drop!\n");
727 }else if (nb_frames > 1) {
728 nb_frames_dup += nb_frames;
730 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
733 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
735 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
739 if (ost->video_crop) {
740 if (img_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
741 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
744 formatted_picture = &picture_crop_temp;
746 formatted_picture = in_picture;
749 final_picture = formatted_picture;
750 padding_src = formatted_picture;
751 resampling_dst = &ost->pict_tmp;
752 if (ost->video_pad) {
753 final_picture = &ost->pict_tmp;
754 if (ost->video_resample) {
755 if (img_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
756 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
759 resampling_dst = &picture_pad_temp;
763 if (ost->video_resample) {
765 final_picture = &ost->pict_tmp;
766 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
767 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
770 if (ost->video_pad) {
771 img_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
772 enc->height, enc->width, enc->pix_fmt,
773 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
776 /* duplicates frame if needed */
777 for(i=0;i<nb_frames;i++) {
779 av_init_packet(&pkt);
780 pkt.stream_index= ost->index;
782 if (s->oformat->flags & AVFMT_RAWPICTURE) {
783 /* raw pictures are written as AVPicture structure to
784 avoid any copies. We support temorarily the older
786 AVFrame* old_frame = enc->coded_frame;
787 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
788 pkt.data= (uint8_t *)final_picture;
789 pkt.size= sizeof(AVPicture);
790 if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
791 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
792 if(dec->coded_frame && dec->coded_frame->key_frame)
793 pkt.flags |= PKT_FLAG_KEY;
795 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
796 enc->coded_frame = old_frame;
800 big_picture= *final_picture;
801 /* better than nothing: use input picture interlaced
803 big_picture.interlaced_frame = in_picture->interlaced_frame;
804 if(avctx_opts->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
805 if(top_field_first == -1)
806 big_picture.top_field_first = in_picture->top_field_first;
808 big_picture.top_field_first = top_field_first;
811 /* handles sameq here. This is not correct because it may
812 not be a global option */
814 big_picture.quality = ist->st->quality;
816 big_picture.quality = ost->st->quality;
818 big_picture.pict_type = 0;
819 // big_picture.pts = AV_NOPTS_VALUE;
820 big_picture.pts= ost->sync_opts;
821 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
822 //av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
823 ret = avcodec_encode_video(enc,
824 bit_buffer, bit_buffer_size,
827 fprintf(stderr, "Video encoding failed\n");
830 //enc->frame_number = enc->real_pict_num;
832 pkt.data= bit_buffer;
834 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
835 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
836 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n",
837 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
838 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
840 if(enc->coded_frame && enc->coded_frame->key_frame)
841 pkt.flags |= PKT_FLAG_KEY;
842 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
844 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
845 // enc->frame_number-1, enc->real_pict_num, ret,
847 /* if two pass, output log */
848 if (ost->logfile && enc->stats_out) {
849 fprintf(ost->logfile, "%s", enc->stats_out);
861 static double psnr(double d){
862 if(d==0) return INFINITY;
863 return -10.0*log(d)/log(10.0);
866 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
869 static FILE *fvstats=NULL;
876 double ti1, bitrate, avg_bitrate;
880 today = localtime(&today2);
881 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
884 fvstats = fopen(filename,"w");
892 enc = ost->st->codec;
893 if (enc->codec_type == CODEC_TYPE_VIDEO) {
894 frame_number = ost->frame_number;
895 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
896 if (enc->flags&CODEC_FLAG_PSNR)
897 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
899 fprintf(fvstats,"f_size= %6d ", frame_size);
900 /* compute pts value */
901 ti1 = ost->sync_opts * av_q2d(enc->time_base);
905 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
906 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
907 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
908 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
909 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
913 static void print_report(AVFormatContext **output_files,
914 AVOutputStream **ost_table, int nb_ostreams,
919 AVFormatContext *oc, *os;
922 int frame_number, vid, i;
923 double bitrate, ti1, pts;
924 static int64_t last_time = -1;
925 static int qp_histogram[52];
927 if (!is_last_report) {
929 /* display the report every 0.5 seconds */
930 cur_time = av_gettime();
931 if (last_time == -1) {
932 last_time = cur_time;
935 if ((cur_time - last_time) < 500000)
937 last_time = cur_time;
941 oc = output_files[0];
943 total_size = url_ftell(&oc->pb);
948 for(i=0;i<nb_ostreams;i++) {
950 os = output_files[ost->file_index];
951 enc = ost->st->codec;
952 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
953 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
954 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
956 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
957 frame_number = ost->frame_number;
958 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%3.1f ",
959 frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
961 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
962 if(qp_hist && enc->coded_frame){
964 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
965 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
968 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
970 if (enc->flags&CODEC_FLAG_PSNR){
972 double error, error_sum=0;
973 double scale, scale_sum=0;
974 char type[3]= {'Y','U','V'};
975 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
978 error= enc->error[j];
979 scale= enc->width*enc->height*255.0*255.0*frame_number;
981 error= enc->coded_frame->error[j];
982 scale= enc->width*enc->height*255.0*255.0;
987 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
989 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
993 /* compute min output value */
994 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
995 if ((pts < ti1) && (pts > 0))
1001 if (verbose || is_last_report) {
1002 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1004 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1005 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1006 (double)total_size / 1024, ti1, bitrate);
1009 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1010 nb_frames_dup, nb_frames_drop);
1013 fprintf(stderr, "%s \r", buf);
1018 if (is_last_report && verbose >= 0){
1019 int64_t raw= audio_size + video_size + extra_size;
1020 fprintf(stderr, "\n");
1021 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1025 100.0*(total_size - raw)/raw
1030 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1031 static int output_packet(AVInputStream *ist, int ist_index,
1032 AVOutputStream **ost_table, int nb_ostreams,
1033 const AVPacket *pkt)
1035 AVFormatContext *os;
1036 AVOutputStream *ost;
1040 int data_size, got_picture;
1042 void *buffer_to_free;
1043 static unsigned int samples_size= 0;
1044 static short *samples= NULL;
1045 AVSubtitle subtitle, *subtitle_to_free;
1049 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1050 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1051 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1053 // assert(ist->pts == ist->next_pts);
1067 /* decode the packet if needed */
1068 data_buf = NULL; /* fail safe */
1070 subtitle_to_free = NULL;
1071 if (ist->decoding_needed) {
1072 switch(ist->st->codec->codec_type) {
1073 case CODEC_TYPE_AUDIO:{
1075 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1076 /* XXX: could avoid copy if PCM 16 bits with same
1077 endianness as CPU */
1078 ret = avcodec_decode_audio(ist->st->codec, samples, &data_size,
1084 /* Some bug in mpeg audio decoder gives */
1085 /* data_size < 0, it seems they are overflows */
1086 if (data_size <= 0) {
1087 /* no audio frame */
1090 data_buf = (uint8_t *)samples;
1091 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1092 (ist->st->codec->sample_rate * ist->st->codec->channels);
1094 case CODEC_TYPE_VIDEO:
1095 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1096 /* XXX: allocate picture correctly */
1097 avcodec_get_frame_defaults(&picture);
1099 ret = avcodec_decode_video(ist->st->codec,
1100 &picture, &got_picture, ptr, len);
1101 ist->st->quality= picture.quality;
1105 /* no picture yet */
1106 goto discard_packet;
1108 if (ist->st->codec->time_base.num != 0) {
1109 ist->next_pts += ((int64_t)AV_TIME_BASE *
1110 ist->st->codec->time_base.num) /
1111 ist->st->codec->time_base.den;
1115 case CODEC_TYPE_SUBTITLE:
1116 ret = avcodec_decode_subtitle(ist->st->codec,
1117 &subtitle, &got_subtitle, ptr, len);
1120 if (!got_subtitle) {
1121 goto discard_packet;
1123 subtitle_to_free = &subtitle;
1130 switch(ist->st->codec->codec_type) {
1131 case CODEC_TYPE_AUDIO:
1132 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1133 (ist->st->codec->sample_rate * ist->st->codec->channels);
1135 case CODEC_TYPE_VIDEO:
1136 if (ist->st->codec->time_base.num != 0) {
1137 ist->next_pts += ((int64_t)AV_TIME_BASE *
1138 ist->st->codec->time_base.num) /
1139 ist->st->codec->time_base.den;
1149 buffer_to_free = NULL;
1150 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1151 pre_process_video_frame(ist, (AVPicture *)&picture,
1155 // preprocess audio (volume)
1156 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1157 if (audio_volume != 256) {
1160 for(i=0;i<(data_size / sizeof(short));i++) {
1161 int v = ((*volp) * audio_volume + 128) >> 8;
1162 if (v < -32768) v = -32768;
1163 if (v > 32767) v = 32767;
1169 /* frame rate emulation */
1170 if (ist->st->codec->rate_emu) {
1171 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1172 int64_t now = av_gettime() - ist->start;
1180 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1181 is the one of the next displayed one */
1182 /* XXX: add mpeg4 too ? */
1183 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1184 if (ist->st->codec->pict_type != B_TYPE) {
1186 tmp = ist->last_ip_pts;
1187 ist->last_ip_pts = ist->frac_pts.val;
1188 ist->frac_pts.val = tmp;
1192 /* if output time reached then transcode raw format,
1193 encode packets and output them */
1194 if (start_time == 0 || ist->pts >= start_time)
1195 for(i=0;i<nb_ostreams;i++) {
1199 if (ost->source_index == ist_index) {
1200 os = output_files[ost->file_index];
1203 printf("%d: got pts=%0.3f %0.3f\n", i,
1204 (double)pkt->pts / AV_TIME_BASE,
1205 ((double)ist->pts / AV_TIME_BASE) -
1206 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1208 /* set the input output pts pairs */
1209 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1211 if (ost->encoding_needed) {
1212 switch(ost->st->codec->codec_type) {
1213 case CODEC_TYPE_AUDIO:
1214 do_audio_out(os, ost, ist, data_buf, data_size);
1216 case CODEC_TYPE_VIDEO:
1217 do_video_out(os, ost, ist, &picture, &frame_size);
1218 video_size += frame_size;
1219 if (do_vstats && frame_size)
1220 do_video_stats(os, ost, frame_size);
1222 case CODEC_TYPE_SUBTITLE:
1223 do_subtitle_out(os, ost, ist, &subtitle,
1230 AVFrame avframe; //FIXME/XXX remove this
1232 av_init_packet(&opkt);
1234 /* no reencoding needed : output the packet directly */
1235 /* force the input stream PTS */
1237 avcodec_get_frame_defaults(&avframe);
1238 ost->st->codec->coded_frame= &avframe;
1239 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1241 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1242 audio_size += data_size;
1243 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1244 video_size += data_size;
1248 opkt.stream_index= ost->index;
1249 if(pkt->pts != AV_NOPTS_VALUE)
1250 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);
1252 opkt.pts= AV_NOPTS_VALUE;
1256 if (pkt->dts == AV_NOPTS_VALUE)
1257 dts = ist->next_pts;
1259 dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1260 opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
1262 opkt.flags= pkt->flags;
1264 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1265 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1266 opkt.destruct= av_destruct_packet;
1268 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1269 ost->st->codec->frame_number++;
1270 ost->frame_number++;
1271 av_free_packet(&opkt);
1275 av_free(buffer_to_free);
1276 /* XXX: allocate the subtitles in the codec ? */
1277 if (subtitle_to_free) {
1278 if (subtitle_to_free->rects != NULL) {
1279 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1280 av_free(subtitle_to_free->rects[i].bitmap);
1281 av_free(subtitle_to_free->rects[i].rgba_palette);
1283 av_freep(&subtitle_to_free->rects);
1285 subtitle_to_free->num_rects = 0;
1286 subtitle_to_free = NULL;
1293 for(i=0;i<nb_ostreams;i++) {
1295 if (ost->source_index == ist_index) {
1296 AVCodecContext *enc= ost->st->codec;
1297 os = output_files[ost->file_index];
1299 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1301 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1304 if (ost->encoding_needed) {
1308 av_init_packet(&pkt);
1309 pkt.stream_index= ost->index;
1311 switch(ost->st->codec->codec_type) {
1312 case CODEC_TYPE_AUDIO:
1313 fifo_bytes = av_fifo_size(&ost->fifo);
1315 /* encode any samples remaining in fifo */
1316 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1317 int fs_tmp = enc->frame_size;
1318 enc->frame_size = fifo_bytes / (2 * enc->channels);
1319 if(av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes) == 0) {
1320 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1322 enc->frame_size = fs_tmp;
1325 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1328 pkt.flags |= PKT_FLAG_KEY;
1330 case CODEC_TYPE_VIDEO:
1331 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1333 if(enc->coded_frame && enc->coded_frame->key_frame)
1334 pkt.flags |= PKT_FLAG_KEY;
1335 if (ost->logfile && enc->stats_out) {
1336 fprintf(ost->logfile, "%s", enc->stats_out);
1345 pkt.data= bit_buffer;
1347 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1348 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1349 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1363 * The following code is the main loop of the file converter
1365 static int av_encode(AVFormatContext **output_files,
1366 int nb_output_files,
1367 AVFormatContext **input_files,
1369 AVStreamMap *stream_maps, int nb_stream_maps)
1371 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1372 AVFormatContext *is, *os;
1373 AVCodecContext *codec, *icodec;
1374 AVOutputStream *ost, **ost_table = NULL;
1375 AVInputStream *ist, **ist_table = NULL;
1376 AVInputFile *file_table;
1377 AVFormatContext *stream_no_data;
1380 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1384 /* input stream init */
1386 for(i=0;i<nb_input_files;i++) {
1387 is = input_files[i];
1388 file_table[i].ist_index = j;
1389 file_table[i].nb_streams = is->nb_streams;
1390 j += is->nb_streams;
1394 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1398 for(i=0;i<nb_istreams;i++) {
1399 ist = av_mallocz(sizeof(AVInputStream));
1405 for(i=0;i<nb_input_files;i++) {
1406 is = input_files[i];
1407 for(k=0;k<is->nb_streams;k++) {
1408 ist = ist_table[j++];
1409 ist->st = is->streams[k];
1410 ist->file_index = i;
1412 ist->discard = 1; /* the stream is discarded by default
1415 if (ist->st->codec->rate_emu) {
1416 ist->start = av_gettime();
1422 /* output stream init */
1424 for(i=0;i<nb_output_files;i++) {
1425 os = output_files[i];
1426 nb_ostreams += os->nb_streams;
1428 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1429 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1433 /* Sanity check the mapping args -- do the input files & streams exist? */
1434 for(i=0;i<nb_stream_maps;i++) {
1435 int fi = stream_maps[i].file_index;
1436 int si = stream_maps[i].stream_index;
1438 if (fi < 0 || fi > nb_input_files - 1 ||
1439 si < 0 || si > file_table[fi].nb_streams - 1) {
1440 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1443 fi = stream_maps[i].sync_file_index;
1444 si = stream_maps[i].sync_stream_index;
1445 if (fi < 0 || fi > nb_input_files - 1 ||
1446 si < 0 || si > file_table[fi].nb_streams - 1) {
1447 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1452 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1455 for(i=0;i<nb_ostreams;i++) {
1456 ost = av_mallocz(sizeof(AVOutputStream));
1463 for(k=0;k<nb_output_files;k++) {
1464 os = output_files[k];
1465 for(i=0;i<os->nb_streams;i++) {
1467 ost = ost_table[n++];
1468 ost->file_index = k;
1470 ost->st = os->streams[i];
1471 if (nb_stream_maps > 0) {
1472 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1473 stream_maps[n-1].stream_index;
1475 /* Sanity check that the stream types match */
1476 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1477 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1478 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1479 ost->file_index, ost->index);
1484 /* get corresponding input stream index : we select the first one with the right type */
1486 for(j=0;j<nb_istreams;j++) {
1489 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1490 ost->source_index = j;
1497 /* try again and reuse existing stream */
1498 for(j=0;j<nb_istreams;j++) {
1500 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1501 ost->source_index = j;
1506 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1507 ost->file_index, ost->index);
1512 ist = ist_table[ost->source_index];
1514 ost->sync_ist = (nb_stream_maps > 0) ?
1515 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1516 stream_maps[n-1].sync_stream_index] : ist;
1520 /* for each output stream, we compute the right encoding parameters */
1521 for(i=0;i<nb_ostreams;i++) {
1523 ist = ist_table[ost->source_index];
1525 codec = ost->st->codec;
1526 icodec = ist->st->codec;
1528 if (ost->st->stream_copy) {
1529 /* if stream_copy is selected, no need to decode or encode */
1530 codec->codec_id = icodec->codec_id;
1531 codec->codec_type = icodec->codec_type;
1532 if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1533 codec->bit_rate = icodec->bit_rate;
1534 codec->extradata= icodec->extradata;
1535 codec->extradata_size= icodec->extradata_size;
1536 codec->time_base = icodec->time_base;
1537 switch(codec->codec_type) {
1538 case CODEC_TYPE_AUDIO:
1539 codec->sample_rate = icodec->sample_rate;
1540 codec->channels = icodec->channels;
1541 codec->frame_size = icodec->frame_size;
1542 codec->block_align= icodec->block_align;
1544 case CODEC_TYPE_VIDEO:
1545 codec->pix_fmt = icodec->pix_fmt;
1546 codec->width = icodec->width;
1547 codec->height = icodec->height;
1548 codec->has_b_frames = icodec->has_b_frames;
1550 case CODEC_TYPE_SUBTITLE:
1556 switch(codec->codec_type) {
1557 case CODEC_TYPE_AUDIO:
1558 if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1561 if (codec->channels == icodec->channels &&
1562 codec->sample_rate == icodec->sample_rate) {
1563 ost->audio_resample = 0;
1565 if (codec->channels != icodec->channels &&
1566 (icodec->codec_id == CODEC_ID_AC3 ||
1567 icodec->codec_id == CODEC_ID_DTS)) {
1568 /* Special case for 5:1 AC3 and DTS input */
1569 /* and mono or stereo output */
1570 /* Request specific number of channels */
1571 icodec->channels = codec->channels;
1572 if (codec->sample_rate == icodec->sample_rate)
1573 ost->audio_resample = 0;
1575 ost->audio_resample = 1;
1578 ost->audio_resample = 1;
1581 if(audio_sync_method>1)
1582 ost->audio_resample = 1;
1584 if(ost->audio_resample){
1585 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1586 codec->sample_rate, icodec->sample_rate);
1588 printf("Can't resample. Aborting.\n");
1592 ist->decoding_needed = 1;
1593 ost->encoding_needed = 1;
1595 case CODEC_TYPE_VIDEO:
1596 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1597 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1598 ost->video_resample = ((codec->width != icodec->width -
1599 (frame_leftBand + frame_rightBand) +
1600 (frame_padleft + frame_padright)) ||
1601 (codec->height != icodec->height -
1602 (frame_topBand + frame_bottomBand) +
1603 (frame_padtop + frame_padbottom)) ||
1604 (codec->pix_fmt != icodec->pix_fmt));
1605 if (ost->video_crop) {
1606 ost->topBand = frame_topBand;
1607 ost->leftBand = frame_leftBand;
1609 if (ost->video_pad) {
1610 ost->padtop = frame_padtop;
1611 ost->padleft = frame_padleft;
1612 ost->padbottom = frame_padbottom;
1613 ost->padright = frame_padright;
1614 if (!ost->video_resample) {
1615 avcodec_get_frame_defaults(&ost->pict_tmp);
1616 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1617 codec->width, codec->height ) )
1621 if (ost->video_resample) {
1622 avcodec_get_frame_defaults(&ost->pict_tmp);
1623 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1624 codec->width, codec->height ) )
1627 ost->img_resample_ctx = sws_getContext(
1628 icodec->width - (frame_leftBand + frame_rightBand),
1629 icodec->height - (frame_topBand + frame_bottomBand),
1631 codec->width - (frame_padleft + frame_padright),
1632 codec->height - (frame_padtop + frame_padbottom),
1634 sws_flags, NULL, NULL, NULL);
1635 if (ost->img_resample_ctx == NULL) {
1636 fprintf(stderr, "Cannot get resampling context\n");
1639 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1641 ost->encoding_needed = 1;
1642 ist->decoding_needed = 1;
1644 case CODEC_TYPE_SUBTITLE:
1645 ost->encoding_needed = 1;
1646 ist->decoding_needed = 1;
1653 if (ost->encoding_needed &&
1654 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1655 char logfilename[1024];
1660 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1662 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1663 if (codec->flags & CODEC_FLAG_PASS1) {
1664 f = fopen(logfilename, "w");
1666 perror(logfilename);
1671 /* read the log file */
1672 f = fopen(logfilename, "r");
1674 perror(logfilename);
1677 fseek(f, 0, SEEK_END);
1679 fseek(f, 0, SEEK_SET);
1680 logbuffer = av_malloc(size + 1);
1682 fprintf(stderr, "Could not allocate log buffer\n");
1685 size = fread(logbuffer, 1, size, f);
1687 logbuffer[size] = '\0';
1688 codec->stats_in = logbuffer;
1692 if(codec->codec_type == CODEC_TYPE_VIDEO){
1693 int size= codec->width * codec->height;
1694 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1699 bit_buffer = av_malloc(bit_buffer_size);
1703 /* dump the file output parameters - cannot be done before in case
1705 for(i=0;i<nb_output_files;i++) {
1706 dump_format(output_files[i], i, output_files[i]->filename, 1);
1709 /* dump the stream mapping */
1711 fprintf(stderr, "Stream mapping:\n");
1712 for(i=0;i<nb_ostreams;i++) {
1714 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1715 ist_table[ost->source_index]->file_index,
1716 ist_table[ost->source_index]->index,
1719 if (ost->sync_ist != ist_table[ost->source_index])
1720 fprintf(stderr, " [sync #%d.%d]",
1721 ost->sync_ist->file_index,
1722 ost->sync_ist->index);
1723 fprintf(stderr, "\n");
1727 /* open each encoder */
1728 for(i=0;i<nb_ostreams;i++) {
1730 if (ost->encoding_needed) {
1732 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1734 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1735 ost->file_index, ost->index);
1738 if (avcodec_open(ost->st->codec, codec) < 0) {
1739 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1740 ost->file_index, ost->index);
1743 extra_size += ost->st->codec->extradata_size;
1747 /* open each decoder */
1748 for(i=0;i<nb_istreams;i++) {
1750 if (ist->decoding_needed) {
1752 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1754 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1755 ist->st->codec->codec_id, ist->file_index, ist->index);
1758 if (avcodec_open(ist->st->codec, codec) < 0) {
1759 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1760 ist->file_index, ist->index);
1763 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1764 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1769 for(i=0;i<nb_istreams;i++) {
1771 is = input_files[ist->file_index];
1773 ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1774 if(ist->st->start_time == AV_NOPTS_VALUE)
1776 if(input_files_ts_offset[ist->file_index])
1777 ist->next_pts= AV_NOPTS_VALUE;
1781 /* compute buffer size max (should use a complete heuristic) */
1782 for(i=0;i<nb_input_files;i++) {
1783 file_table[i].buffer_size_max = 2048;
1786 /* set meta data information from input file if required */
1787 for (i=0;i<nb_meta_data_maps;i++) {
1788 AVFormatContext *out_file;
1789 AVFormatContext *in_file;
1791 int out_file_index = meta_data_maps[i].out_file;
1792 int in_file_index = meta_data_maps[i].in_file;
1793 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1794 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1798 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1799 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1804 out_file = output_files[out_file_index];
1805 in_file = input_files[in_file_index];
1807 strcpy(out_file->title, in_file->title);
1808 strcpy(out_file->author, in_file->author);
1809 strcpy(out_file->copyright, in_file->copyright);
1810 strcpy(out_file->comment, in_file->comment);
1811 strcpy(out_file->album, in_file->album);
1812 out_file->year = in_file->year;
1813 out_file->track = in_file->track;
1814 strcpy(out_file->genre, in_file->genre);
1817 /* open files and write file headers */
1818 for(i=0;i<nb_output_files;i++) {
1819 os = output_files[i];
1820 if (av_write_header(os) < 0) {
1821 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1828 if ( !using_stdin && verbose >= 0) {
1829 fprintf(stderr, "Press [q] to stop encoding\n");
1830 url_set_interrupt_cb(decode_interrupt_cb);
1838 for(; received_sigterm == 0;) {
1839 int file_index, ist_index;
1847 /* if 'q' pressed, exits */
1851 /* read_key() returns 0 on EOF */
1857 /* select the stream that we must read now by looking at the
1858 smallest output pts */
1860 for(i=0;i<nb_ostreams;i++) {
1863 os = output_files[ost->file_index];
1864 ist = ist_table[ost->source_index];
1865 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1866 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1868 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1869 ipts = (double)ist->pts;
1870 if (!file_table[ist->file_index].eof_reached){
1871 if(ipts < ipts_min) {
1873 if(input_sync ) file_index = ist->file_index;
1875 if(opts < opts_min) {
1877 if(!input_sync) file_index = ist->file_index;
1880 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1885 /* if none, if is finished */
1886 if (file_index < 0) {
1890 /* finish if recording time exhausted */
1891 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1894 /* finish if limit size exhausted */
1895 if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1898 /* read a frame from it and output it in the fifo */
1899 is = input_files[file_index];
1900 if (av_read_frame(is, &pkt) < 0) {
1901 file_table[file_index].eof_reached = 1;
1902 if (opt_shortest) break; else continue; //
1906 stream_no_data = is;
1911 av_pkt_dump(stdout, &pkt, do_hex_dump);
1913 /* the following test is needed in case new streams appear
1914 dynamically in stream : we ignore them */
1915 if (pkt.stream_index >= file_table[file_index].nb_streams)
1916 goto discard_packet;
1917 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1918 ist = ist_table[ist_index];
1920 goto discard_packet;
1922 // 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);
1923 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1924 int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1925 if(ABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1926 input_files_ts_offset[ist->file_index]-= delta;
1928 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1929 for(i=0; i<file_table[file_index].nb_streams; i++){
1930 int index= file_table[file_index].ist_index + i;
1931 ist_table[index]->next_pts += delta;
1932 ist_table[index]->is_start=1;
1937 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1938 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1941 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1942 ist->file_index, ist->index);
1944 av_free_packet(&pkt);
1949 av_free_packet(&pkt);
1951 /* dump report by using the output first video and audio streams */
1952 print_report(output_files, ost_table, nb_ostreams, 0);
1955 /* at the end of stream, we must flush the decoder buffers */
1956 for(i=0;i<nb_istreams;i++) {
1958 if (ist->decoding_needed) {
1959 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1965 /* write the trailer if needed and close file */
1966 for(i=0;i<nb_output_files;i++) {
1967 os = output_files[i];
1968 av_write_trailer(os);
1971 /* dump report by using the first video and audio streams */
1972 print_report(output_files, ost_table, nb_ostreams, 1);
1974 /* close each encoder */
1975 for(i=0;i<nb_ostreams;i++) {
1977 if (ost->encoding_needed) {
1978 av_freep(&ost->st->codec->stats_in);
1979 avcodec_close(ost->st->codec);
1983 /* close each decoder */
1984 for(i=0;i<nb_istreams;i++) {
1986 if (ist->decoding_needed) {
1987 avcodec_close(ist->st->codec);
1995 av_freep(&bit_buffer);
1996 av_free(file_table);
1999 for(i=0;i<nb_istreams;i++) {
2006 for(i=0;i<nb_ostreams;i++) {
2010 fclose(ost->logfile);
2011 ost->logfile = NULL;
2013 av_fifo_free(&ost->fifo); /* works even if fifo is not
2014 initialized but set to zero */
2015 av_free(ost->pict_tmp.data[0]);
2016 if (ost->video_resample)
2017 sws_freeContext(ost->img_resample_ctx);
2018 if (ost->audio_resample)
2019 audio_resample_close(ost->resample);
2032 int file_read(const char *filename)
2035 unsigned char buffer[1024];
2038 if (url_open(&h, filename, O_RDONLY) < 0) {
2039 printf("could not open '%s'\n", filename);
2043 len = url_read(h, buffer, sizeof(buffer));
2046 for(i=0;i<len;i++) putchar(buffer[i]);
2053 static void opt_image_format(const char *arg)
2057 for(f = first_image_format; f != NULL; f = f->next) {
2058 if (!strcmp(arg, f->name))
2062 fprintf(stderr, "Unknown image format: '%s'\n", arg);
2068 static void opt_format(const char *arg)
2070 /* compatibility stuff for pgmyuv */
2071 if (!strcmp(arg, "pgmyuv")) {
2072 pgmyuv_compatibility_hack=1;
2073 // opt_image_format(arg);
2077 file_iformat = av_find_input_format(arg);
2078 file_oformat = guess_format(arg, NULL, NULL);
2079 if (!file_iformat && !file_oformat) {
2080 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2085 static void opt_video_rc_eq(char *arg)
2090 static void opt_video_rc_override_string(char *arg)
2092 video_rc_override_string = arg;
2095 static void opt_me_threshold(const char *arg)
2097 me_threshold = atoi(arg);
2100 static void opt_verbose(const char *arg)
2102 verbose = atoi(arg);
2103 av_log_set_level(atoi(arg));
2106 static void opt_frame_rate(const char *arg)
2108 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2109 fprintf(stderr, "Incorrect frame rate\n");
2114 static void opt_frame_crop_top(const char *arg)
2116 frame_topBand = atoi(arg);
2117 if (frame_topBand < 0) {
2118 fprintf(stderr, "Incorrect top crop size\n");
2121 if ((frame_topBand % 2) != 0) {
2122 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2125 if ((frame_topBand) >= frame_height){
2126 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2129 frame_height -= frame_topBand;
2132 static void opt_frame_crop_bottom(const char *arg)
2134 frame_bottomBand = atoi(arg);
2135 if (frame_bottomBand < 0) {
2136 fprintf(stderr, "Incorrect bottom crop size\n");
2139 if ((frame_bottomBand % 2) != 0) {
2140 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2143 if ((frame_bottomBand) >= frame_height){
2144 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2147 frame_height -= frame_bottomBand;
2150 static void opt_frame_crop_left(const char *arg)
2152 frame_leftBand = atoi(arg);
2153 if (frame_leftBand < 0) {
2154 fprintf(stderr, "Incorrect left crop size\n");
2157 if ((frame_leftBand % 2) != 0) {
2158 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2161 if ((frame_leftBand) >= frame_width){
2162 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2165 frame_width -= frame_leftBand;
2168 static void opt_frame_crop_right(const char *arg)
2170 frame_rightBand = atoi(arg);
2171 if (frame_rightBand < 0) {
2172 fprintf(stderr, "Incorrect right crop size\n");
2175 if ((frame_rightBand % 2) != 0) {
2176 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2179 if ((frame_rightBand) >= frame_width){
2180 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2183 frame_width -= frame_rightBand;
2186 static void opt_frame_size(const char *arg)
2188 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2189 fprintf(stderr, "Incorrect frame size\n");
2192 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2193 fprintf(stderr, "Frame size must be a multiple of 2\n");
2199 #define SCALEBITS 10
2200 #define ONE_HALF (1 << (SCALEBITS - 1))
2201 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2203 #define RGB_TO_Y(r, g, b) \
2204 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2205 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2207 #define RGB_TO_U(r1, g1, b1, shift)\
2208 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2209 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2211 #define RGB_TO_V(r1, g1, b1, shift)\
2212 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2213 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2215 static void opt_pad_color(const char *arg) {
2216 /* Input is expected to be six hex digits similar to
2217 how colors are expressed in html tags (but without the #) */
2218 int rgb = strtol(arg, NULL, 16);
2222 g = ((rgb >> 8) & 255);
2225 padcolor[0] = RGB_TO_Y(r,g,b);
2226 padcolor[1] = RGB_TO_U(r,g,b,0);
2227 padcolor[2] = RGB_TO_V(r,g,b,0);
2230 static void opt_frame_pad_top(const char *arg)
2232 frame_padtop = atoi(arg);
2233 if (frame_padtop < 0) {
2234 fprintf(stderr, "Incorrect top pad size\n");
2237 if ((frame_padtop % 2) != 0) {
2238 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2243 static void opt_frame_pad_bottom(const char *arg)
2245 frame_padbottom = atoi(arg);
2246 if (frame_padbottom < 0) {
2247 fprintf(stderr, "Incorrect bottom pad size\n");
2250 if ((frame_padbottom % 2) != 0) {
2251 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2257 static void opt_frame_pad_left(const char *arg)
2259 frame_padleft = atoi(arg);
2260 if (frame_padleft < 0) {
2261 fprintf(stderr, "Incorrect left pad size\n");
2264 if ((frame_padleft % 2) != 0) {
2265 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2271 static void opt_frame_pad_right(const char *arg)
2273 frame_padright = atoi(arg);
2274 if (frame_padright < 0) {
2275 fprintf(stderr, "Incorrect right pad size\n");
2278 if ((frame_padright % 2) != 0) {
2279 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2285 static void opt_frame_pix_fmt(const char *arg)
2287 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2290 static void opt_frame_aspect_ratio(const char *arg)
2296 p = strchr(arg, ':');
2298 x = strtol(arg, (char **)&arg, 10);
2300 y = strtol(arg+1, (char **)&arg, 10);
2302 ar = (double)x / (double)y;
2304 ar = strtod(arg, (char **)&arg);
2307 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2310 frame_aspect_ratio = ar;
2313 static void opt_qscale(const char *arg)
2315 video_qscale = atof(arg);
2316 if (video_qscale <= 0 ||
2317 video_qscale > 255) {
2318 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2323 static void opt_qdiff(const char *arg)
2325 video_qdiff = atoi(arg);
2326 if (video_qdiff < 0 ||
2328 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2333 static void opt_packet_size(const char *arg)
2335 packet_size= atoi(arg);
2338 static void opt_strict(const char *arg)
2343 static void opt_top_field_first(const char *arg)
2345 top_field_first= atoi(arg);
2348 static void opt_thread_count(const char *arg)
2350 thread_count= atoi(arg);
2351 #if !defined(HAVE_THREADS)
2353 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2357 static void opt_audio_bitrate(const char *arg)
2359 audio_bit_rate = atoi(arg) * 1000;
2362 static void opt_audio_rate(const char *arg)
2364 audio_sample_rate = atoi(arg);
2367 static void opt_audio_channels(const char *arg)
2369 audio_channels = atoi(arg);
2372 static void opt_video_device(const char *arg)
2374 video_device = av_strdup(arg);
2377 static void opt_grab_device(const char *arg)
2379 grab_device = av_strdup(arg);
2382 static void opt_video_channel(const char *arg)
2384 video_channel = strtol(arg, NULL, 0);
2387 static void opt_video_standard(const char *arg)
2389 video_standard = av_strdup(arg);
2392 static void opt_audio_device(const char *arg)
2394 audio_device = av_strdup(arg);
2397 static void opt_codec(int *pstream_copy, int *pcodec_id,
2398 int codec_type, const char *arg)
2402 if (!strcmp(arg, "copy")) {
2407 if (!strcmp(p->name, arg) && p->type == codec_type)
2412 fprintf(stderr, "Unknown codec '%s'\n", arg);
2420 static void opt_audio_codec(const char *arg)
2422 opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2425 static void opt_audio_tag(const char *arg)
2428 audio_codec_tag= strtol(arg, &tail, 0);
2431 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2434 static void opt_video_tag(const char *arg)
2437 video_codec_tag= strtol(arg, &tail, 0);
2440 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2443 static void add_frame_hooker(const char *arg)
2448 char *args = av_strdup(arg);
2452 argv[0] = strtok(args, " ");
2453 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2456 i = frame_hook_add(argc, argv);
2459 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2464 const char *motion_str[] = {
2477 static void opt_motion_estimation(const char *arg)
2483 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2486 if (!strcmp(*p, arg))
2490 me_method = (p - motion_str) + 1;
2493 static void opt_video_codec(const char *arg)
2495 opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2498 static void opt_subtitle_codec(const char *arg)
2500 opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2503 static void opt_map(const char *arg)
2509 m = &stream_maps[nb_stream_maps++];
2511 m->file_index = strtol(arg, (char **)&p, 0);
2515 m->stream_index = strtol(p, (char **)&p, 0);
2518 m->sync_file_index = strtol(p, (char **)&p, 0);
2521 m->sync_stream_index = strtol(p, (char **)&p, 0);
2523 m->sync_file_index = m->file_index;
2524 m->sync_stream_index = m->stream_index;
2528 static void opt_map_meta_data(const char *arg)
2534 m = &meta_data_maps[nb_meta_data_maps++];
2536 m->out_file = strtol(arg, (char **)&p, 0);
2540 m->in_file = strtol(p, (char **)&p, 0);
2543 static void opt_recording_time(const char *arg)
2545 recording_time = parse_date(arg, 1);
2548 static void opt_start_time(const char *arg)
2550 start_time = parse_date(arg, 1);
2553 static void opt_rec_timestamp(const char *arg)
2555 rec_timestamp = parse_date(arg, 0) / 1000000;
2558 static void opt_input_ts_offset(const char *arg)
2560 input_ts_offset = parse_date(arg, 1);
2563 static void opt_input_file(const char *filename)
2565 AVFormatContext *ic;
2566 AVFormatParameters params, *ap = ¶ms;
2567 int err, i, ret, rfps, rfps_base;
2570 if (!strcmp(filename, "-"))
2573 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2574 !strcmp( filename, "/dev/stdin" );
2576 /* get default parameters from command line */
2577 ic = av_alloc_format_context();
2579 memset(ap, 0, sizeof(*ap));
2580 ap->prealloced_context = 1;
2581 ap->sample_rate = audio_sample_rate;
2582 ap->channels = audio_channels;
2583 ap->time_base.den = frame_rate;
2584 ap->time_base.num = frame_rate_base;
2585 ap->width = frame_width + frame_padleft + frame_padright;
2586 ap->height = frame_height + frame_padtop + frame_padbottom;
2587 ap->image_format = image_format;
2588 ap->pix_fmt = frame_pix_fmt;
2589 ap->device = grab_device;
2590 ap->channel = video_channel;
2591 ap->standard = video_standard;
2592 ap->video_codec_id = video_codec_id;
2593 ap->audio_codec_id = audio_codec_id;
2594 if(pgmyuv_compatibility_hack)
2595 ap->video_codec_id= CODEC_ID_PGMYUV;
2597 for(i=0; i<opt_name_count; i++){
2599 double d= av_get_double(avformat_opts, opt_names[i], &opt);
2600 if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2601 av_set_double(ic, opt_names[i], d);
2603 /* open the input file with generic libav function */
2604 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2606 print_error(filename, err);
2610 ic->loop_input = loop_input;
2612 /* If not enough info to get the stream parameters, we decode the
2613 first frames to get it. (used in mpeg case for example) */
2614 ret = av_find_stream_info(ic);
2615 if (ret < 0 && verbose >= 0) {
2616 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2620 timestamp = start_time;
2621 /* add the stream start time */
2622 if (ic->start_time != AV_NOPTS_VALUE)
2623 timestamp += ic->start_time;
2625 /* if seeking requested, we execute it */
2626 if (start_time != 0) {
2627 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2629 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2630 filename, (double)timestamp / AV_TIME_BASE);
2632 /* reset seek info */
2636 /* update the current parameters so that they match the one of the input stream */
2637 for(i=0;i<ic->nb_streams;i++) {
2639 AVCodecContext *enc = ic->streams[i]->codec;
2640 #if defined(HAVE_THREADS)
2642 avcodec_thread_init(enc, thread_count);
2644 enc->thread_count= thread_count;
2645 switch(enc->codec_type) {
2646 case CODEC_TYPE_AUDIO:
2647 for(j=0; j<opt_name_count; j++){
2649 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2650 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2651 av_set_double(enc, opt_names[j], d);
2653 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2654 audio_channels = enc->channels;
2655 audio_sample_rate = enc->sample_rate;
2657 ic->streams[i]->discard= AVDISCARD_ALL;
2659 case CODEC_TYPE_VIDEO:
2660 for(j=0; j<opt_name_count; j++){
2662 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2663 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2664 av_set_double(enc, opt_names[j], d);
2666 frame_height = enc->height;
2667 frame_width = enc->width;
2668 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2669 frame_pix_fmt = enc->pix_fmt;
2670 rfps = ic->streams[i]->r_frame_rate.num;
2671 rfps_base = ic->streams[i]->r_frame_rate.den;
2672 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2674 enc->debug |= FF_DEBUG_MV;
2676 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2679 fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2680 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2682 (float)rfps / rfps_base, rfps, rfps_base);
2684 /* update the current frame rate to match the stream frame rate */
2686 frame_rate_base = rfps_base;
2688 enc->rate_emu = rate_emu;
2690 ic->streams[i]->discard= AVDISCARD_ALL;
2691 else if(video_discard)
2692 ic->streams[i]->discard= video_discard;
2694 case CODEC_TYPE_DATA:
2696 case CODEC_TYPE_SUBTITLE:
2698 case CODEC_TYPE_UNKNOWN:
2705 input_files[nb_input_files] = ic;
2706 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2707 /* dump the file content */
2709 dump_format(ic, nb_input_files, filename, 0);
2712 file_iformat = NULL;
2713 file_oformat = NULL;
2714 image_format = NULL;
2722 static void opt_grab(const char *arg)
2724 file_iformat = av_find_input_format(arg);
2728 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2730 int has_video, has_audio, i, j;
2731 AVFormatContext *ic;
2735 for(j=0;j<nb_input_files;j++) {
2736 ic = input_files[j];
2737 for(i=0;i<ic->nb_streams;i++) {
2738 AVCodecContext *enc = ic->streams[i]->codec;
2739 switch(enc->codec_type) {
2740 case CODEC_TYPE_AUDIO:
2743 case CODEC_TYPE_VIDEO:
2746 case CODEC_TYPE_DATA:
2747 case CODEC_TYPE_UNKNOWN:
2748 case CODEC_TYPE_SUBTITLE:
2755 *has_video_ptr = has_video;
2756 *has_audio_ptr = has_audio;
2759 static void new_video_stream(AVFormatContext *oc)
2762 AVCodecContext *video_enc;
2765 st = av_new_stream(oc, oc->nb_streams);
2767 fprintf(stderr, "Could not alloc stream\n");
2770 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2771 video_bitstream_filters= NULL;
2773 #if defined(HAVE_THREADS)
2775 avcodec_thread_init(st->codec, thread_count);
2778 video_enc = st->codec;
2781 video_enc->codec_tag= video_codec_tag;
2783 if( (video_global_header&1)
2784 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2785 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2786 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2788 if(video_global_header&2){
2789 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2790 avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2793 if (video_stream_copy) {
2794 st->stream_copy = 1;
2795 video_enc->codec_type = CODEC_TYPE_VIDEO;
2801 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2802 if (video_codec_id != CODEC_ID_NONE)
2803 codec_id = video_codec_id;
2805 video_enc->codec_id = codec_id;
2806 codec = avcodec_find_encoder(codec_id);
2808 for(i=0; i<opt_name_count; i++){
2810 double d= av_get_double(avctx_opts, opt_names[i], &opt);
2811 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2812 av_set_double(video_enc, opt_names[i], d);
2815 video_enc->time_base.den = frame_rate;
2816 video_enc->time_base.num = frame_rate_base;
2817 if(codec && codec->supported_framerates){
2818 const AVRational *p= codec->supported_framerates;
2819 AVRational req= (AVRational){frame_rate, frame_rate_base};
2820 const AVRational *best=NULL;
2821 AVRational best_error= (AVRational){INT_MAX, 1};
2822 for(; p->den!=0; p++){
2823 AVRational error= av_sub_q(req, *p);
2824 if(error.num <0) error.num *= -1;
2825 if(av_cmp_q(error, best_error) < 0){
2830 video_enc->time_base.den= best->num;
2831 video_enc->time_base.num= best->den;
2834 video_enc->width = frame_width + frame_padright + frame_padleft;
2835 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2836 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2837 video_enc->pix_fmt = frame_pix_fmt;
2839 if(codec && codec->pix_fmts){
2840 const enum PixelFormat *p= codec->pix_fmts;
2842 if(*p == video_enc->pix_fmt)
2846 video_enc->pix_fmt = codec->pix_fmts[0];
2850 video_enc->gop_size = 0;
2851 if (video_qscale || same_quality) {
2852 video_enc->flags |= CODEC_FLAG_QSCALE;
2853 video_enc->global_quality=
2854 st->quality = FF_QP2LAMBDA * video_qscale;
2858 video_enc->intra_matrix = intra_matrix;
2860 video_enc->inter_matrix = inter_matrix;
2862 video_enc->max_qdiff = video_qdiff;
2863 video_enc->rc_eq = video_rc_eq;
2864 video_enc->thread_count = thread_count;
2865 p= video_rc_override_string;
2868 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2870 fprintf(stderr, "error parsing rc_override\n");
2873 video_enc->rc_override=
2874 av_realloc(video_enc->rc_override,
2875 sizeof(RcOverride)*(i+1));
2876 video_enc->rc_override[i].start_frame= start;
2877 video_enc->rc_override[i].end_frame = end;
2879 video_enc->rc_override[i].qscale= q;
2880 video_enc->rc_override[i].quality_factor= 1.0;
2883 video_enc->rc_override[i].qscale= 0;
2884 video_enc->rc_override[i].quality_factor= -q/100.0;
2889 video_enc->rc_override_count=i;
2890 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2891 video_enc->me_threshold= me_threshold;
2892 video_enc->intra_dc_precision= intra_dc_precision - 8;
2893 video_enc->strict_std_compliance = strict;
2896 video_enc->rtp_mode= 1;
2897 video_enc->rtp_payload_size= packet_size;
2901 video_enc->flags|= CODEC_FLAG_PSNR;
2903 video_enc->me_method = me_method;
2908 video_enc->flags |= CODEC_FLAG_PASS1;
2910 video_enc->flags |= CODEC_FLAG_PASS2;
2915 /* reset some key parameters */
2917 video_codec_id = CODEC_ID_NONE;
2918 video_stream_copy = 0;
2921 static void new_audio_stream(AVFormatContext *oc)
2924 AVCodecContext *audio_enc;
2927 st = av_new_stream(oc, oc->nb_streams);
2929 fprintf(stderr, "Could not alloc stream\n");
2933 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2934 audio_bitstream_filters= NULL;
2936 #if defined(HAVE_THREADS)
2938 avcodec_thread_init(st->codec, thread_count);
2941 audio_enc = st->codec;
2942 audio_enc->codec_type = CODEC_TYPE_AUDIO;
2945 audio_enc->codec_tag= audio_codec_tag;
2947 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2948 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2949 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2951 if (audio_stream_copy) {
2952 st->stream_copy = 1;
2953 audio_enc->channels = audio_channels;
2955 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2957 for(i=0; i<opt_name_count; i++){
2959 double d= av_get_double(avctx_opts, opt_names[i], &opt);
2960 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2961 av_set_double(audio_enc, opt_names[i], d);
2964 if (audio_codec_id != CODEC_ID_NONE)
2965 codec_id = audio_codec_id;
2966 audio_enc->codec_id = codec_id;
2968 audio_enc->bit_rate = audio_bit_rate;
2969 if (audio_qscale > QSCALE_NONE) {
2970 audio_enc->flags |= CODEC_FLAG_QSCALE;
2971 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
2973 audio_enc->strict_std_compliance = strict;
2974 audio_enc->thread_count = thread_count;
2975 /* For audio codecs other than AC3 or DTS we limit */
2976 /* the number of coded channels to stereo */
2977 if (audio_channels > 2 && codec_id != CODEC_ID_AC3
2978 && codec_id != CODEC_ID_DTS) {
2979 audio_enc->channels = 2;
2981 audio_enc->channels = audio_channels;
2983 audio_enc->sample_rate = audio_sample_rate;
2984 audio_enc->time_base= (AVRational){1, audio_sample_rate};
2985 if (audio_language) {
2986 pstrcpy(st->language, sizeof(st->language), audio_language);
2987 av_free(audio_language);
2988 audio_language = NULL;
2991 /* reset some key parameters */
2993 audio_codec_id = CODEC_ID_NONE;
2994 audio_stream_copy = 0;
2997 static void opt_new_subtitle_stream(void)
2999 AVFormatContext *oc;
3001 AVCodecContext *subtitle_enc;
3004 if (nb_output_files <= 0) {
3005 fprintf(stderr, "At least one output file must be specified\n");
3008 oc = output_files[nb_output_files - 1];
3010 st = av_new_stream(oc, oc->nb_streams);
3012 fprintf(stderr, "Could not alloc stream\n");
3016 subtitle_enc = st->codec;
3017 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3018 if (subtitle_stream_copy) {
3019 st->stream_copy = 1;
3021 for(i=0; i<opt_name_count; i++){
3023 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3024 if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3025 av_set_double(subtitle_enc, opt_names[i], d);
3027 subtitle_enc->codec_id = subtitle_codec_id;
3030 if (subtitle_language) {
3031 pstrcpy(st->language, sizeof(st->language), subtitle_language);
3032 av_free(subtitle_language);
3033 subtitle_language = NULL;
3036 subtitle_codec_id = CODEC_ID_NONE;
3037 subtitle_stream_copy = 0;
3040 static void opt_new_audio_stream(void)
3042 AVFormatContext *oc;
3043 if (nb_output_files <= 0) {
3044 fprintf(stderr, "At least one output file must be specified\n");
3047 oc = output_files[nb_output_files - 1];
3048 new_audio_stream(oc);
3051 static void opt_new_video_stream(void)
3053 AVFormatContext *oc;
3054 if (nb_output_files <= 0) {
3055 fprintf(stderr, "At least one output file must be specified\n");
3058 oc = output_files[nb_output_files - 1];
3059 new_video_stream(oc);
3062 static void opt_output_file(const char *filename)
3064 AVFormatContext *oc;
3065 int use_video, use_audio, input_has_video, input_has_audio, i;
3066 AVFormatParameters params, *ap = ¶ms;
3068 if (!strcmp(filename, "-"))
3071 oc = av_alloc_format_context();
3073 if (!file_oformat) {
3074 file_oformat = guess_format(NULL, filename, NULL);
3075 if (!file_oformat) {
3076 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3082 oc->oformat = file_oformat;
3083 pstrcpy(oc->filename, sizeof(oc->filename), filename);
3085 if (!strcmp(file_oformat->name, "ffm") &&
3086 strstart(filename, "http:", NULL)) {
3087 /* special case for files sent to ffserver: we get the stream
3088 parameters from ffserver */
3089 if (read_ffserver_streams(oc, filename) < 0) {
3090 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3094 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3095 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3097 /* disable if no corresponding type found and at least one
3099 if (nb_input_files > 0) {
3100 check_audio_video_inputs(&input_has_video, &input_has_audio);
3101 if (!input_has_video)
3103 if (!input_has_audio)
3107 /* manual disable */
3108 if (audio_disable) {
3111 if (video_disable) {
3116 new_video_stream(oc);
3120 new_audio_stream(oc);
3123 if (!oc->nb_streams) {
3124 fprintf(stderr, "No audio or video streams available\n");
3128 oc->timestamp = rec_timestamp;
3131 pstrcpy(oc->title, sizeof(oc->title), str_title);
3133 pstrcpy(oc->author, sizeof(oc->author), str_author);
3135 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3137 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3139 pstrcpy(oc->album, sizeof(oc->album), str_album);
3142 output_files[nb_output_files++] = oc;
3144 /* check filename in case of an image number is expected */
3145 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3146 if (!av_filename_number_test(oc->filename)) {
3147 print_error(oc->filename, AVERROR_NUMEXPECTED);
3152 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3153 /* test if it already exists to avoid loosing precious files */
3154 if (!file_overwrite &&
3155 (strchr(filename, ':') == NULL ||
3156 strstart(filename, "file:", NULL))) {
3157 if (url_exist(filename)) {
3160 if ( !using_stdin ) {
3161 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3164 if (toupper(c) != 'Y') {
3165 fprintf(stderr, "Not overwriting - exiting\n");
3170 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3177 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3178 fprintf(stderr, "Could not open '%s'\n", filename);
3183 memset(ap, 0, sizeof(*ap));
3184 ap->image_format = image_format;
3185 if (av_set_parameters(oc, ap) < 0) {
3186 fprintf(stderr, "%s: Invalid encoding parameters\n",
3191 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3192 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3193 oc->loop_output = loop_output;
3195 for(i=0; i<opt_name_count; i++){
3197 double d = av_get_double(avformat_opts, opt_names[i], &opt);
3198 if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3199 av_set_double(oc, opt_names[i], d);
3202 /* reset some options */
3203 file_oformat = NULL;
3204 file_iformat = NULL;
3205 image_format = NULL;
3208 /* prepare dummy protocols for grab */
3209 static void prepare_grab(void)
3211 int has_video, has_audio, i, j;
3212 AVFormatContext *oc;
3213 AVFormatContext *ic;
3214 AVFormatParameters vp1, *vp = &vp1;
3215 AVFormatParameters ap1, *ap = &ap1;
3217 /* see if audio/video inputs are needed */
3220 memset(ap, 0, sizeof(*ap));
3221 memset(vp, 0, sizeof(*vp));
3222 vp->time_base.num= 1;
3223 for(j=0;j<nb_output_files;j++) {
3224 oc = output_files[j];
3225 for(i=0;i<oc->nb_streams;i++) {
3226 AVCodecContext *enc = oc->streams[i]->codec;
3227 switch(enc->codec_type) {
3228 case CODEC_TYPE_AUDIO:
3229 if (enc->sample_rate > ap->sample_rate)
3230 ap->sample_rate = enc->sample_rate;
3231 if (enc->channels > ap->channels)
3232 ap->channels = enc->channels;
3235 case CODEC_TYPE_VIDEO:
3236 if (enc->width > vp->width)
3237 vp->width = enc->width;
3238 if (enc->height > vp->height)
3239 vp->height = enc->height;
3241 if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3242 vp->time_base = enc->time_base;
3243 vp->width += frame_leftBand + frame_rightBand;
3244 vp->width -= (frame_padleft + frame_padright);
3245 vp->height += frame_topBand + frame_bottomBand;
3246 vp->height -= (frame_padtop + frame_padbottom);
3256 if (has_video == 0 && has_audio == 0) {
3257 fprintf(stderr, "Output file must have at least one audio or video stream\n");
3262 AVInputFormat *fmt1;
3263 fmt1 = av_find_input_format(video_grab_format);
3264 vp->device = video_device;
3265 vp->channel = video_channel;
3266 vp->standard = video_standard;
3267 vp->pix_fmt = frame_pix_fmt;
3268 if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3269 fprintf(stderr, "Could not find video grab device\n");
3272 /* If not enough info to get the stream parameters, we decode the
3273 first frames to get it. */
3274 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3275 fprintf(stderr, "Could not find video grab parameters\n");
3278 /* by now video grab has one stream */
3279 ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3280 ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3281 input_files[nb_input_files] = ic;
3284 dump_format(ic, nb_input_files, "", 0);
3288 if (has_audio && audio_grab_format) {
3289 AVInputFormat *fmt1;
3290 fmt1 = av_find_input_format(audio_grab_format);
3291 ap->device = audio_device;
3292 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3293 fprintf(stderr, "Could not find audio grab device\n");
3296 input_files[nb_input_files] = ic;
3299 dump_format(ic, nb_input_files, "", 0);
3305 /* same option as mencoder */
3306 static void opt_pass(const char *pass_str)
3309 pass = atoi(pass_str);
3310 if (pass != 1 && pass != 2) {
3311 fprintf(stderr, "pass number can be only 1 or 2\n");
3317 #if defined(__MINGW32__) || defined(CONFIG_OS2)
3318 static int64_t getutime(void)
3320 return av_gettime();
3323 static int64_t getutime(void)
3325 struct rusage rusage;
3327 getrusage(RUSAGE_SELF, &rusage);
3328 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3332 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3333 extern int ffm_nopts;
3336 static void show_formats(void)
3338 AVInputFormat *ifmt;
3339 AVOutputFormat *ofmt;
3340 AVImageFormat *image_fmt;
3343 const char **pp, *last_name;
3345 printf("File formats:\n");
3350 const char *name=NULL;
3351 const char *long_name=NULL;
3353 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3354 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3355 strcmp(ofmt->name, last_name)>0){
3357 long_name= ofmt->long_name;
3361 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3362 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3363 strcmp(ifmt->name, last_name)>0){
3365 long_name= ifmt->long_name;
3368 if(name && strcmp(ifmt->name, name)==0)
3380 long_name ? long_name:" ");
3384 printf("Image formats (filename extensions, if any, follow):\n");
3385 for(image_fmt = first_image_format; image_fmt != NULL;
3386 image_fmt = image_fmt->next) {
3389 image_fmt->img_read ? "D":" ",
3390 image_fmt->img_write ? "E":" ",
3392 image_fmt->extensions ? image_fmt->extensions:" ");
3396 printf("Codecs:\n");
3402 const char *type_str;
3405 for(p = first_avcodec; p != NULL; p = p->next) {
3406 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3407 strcmp(p->name, last_name)>0){
3409 decode= encode= cap=0;
3411 if(p2 && strcmp(p->name, p2->name)==0){
3412 if(p->decode) decode=1;
3413 if(p->encode) encode=1;
3414 cap |= p->capabilities;
3419 last_name= p2->name;
3422 case CODEC_TYPE_VIDEO:
3425 case CODEC_TYPE_AUDIO:
3428 case CODEC_TYPE_SUBTITLE:
3437 decode ? "D": (/*p2->decoder ? "d":*/" "),
3440 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3441 cap & CODEC_CAP_DR1 ? "D":" ",
3442 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3444 /* if(p2->decoder && decode==0)
3445 printf(" use %s for decoding", p2->decoder->name);*/
3450 printf("Supported file protocols:\n");
3451 for(up = first_protocol; up != NULL; up = up->next)
3452 printf(" %s:", up->name);
3455 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3456 printf("Motion estimation methods:\n");
3460 if ((pp - motion_str + 1) == ME_ZERO)
3461 printf("(fastest)");
3462 else if ((pp - motion_str + 1) == ME_FULL)
3463 printf("(slowest)");
3464 else if ((pp - motion_str + 1) == ME_EPZS)
3465 printf("(default)");
3470 "Note, the names of encoders and decoders dont always match, so there are\n"
3471 "several cases where the above table shows encoder only or decoder only entries\n"
3472 "even though both encoding and decoding are supported for example, the h263\n"
3473 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3478 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3481 const char *p = str;
3488 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3495 static void opt_inter_matrix(const char *arg)
3497 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3498 parse_matrix_coeffs(inter_matrix, arg);
3501 static void opt_intra_matrix(const char *arg)
3503 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3504 parse_matrix_coeffs(intra_matrix, arg);
3507 static void opt_target(const char *arg)
3510 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3512 if(!strncmp(arg, "pal-", 4)) {
3515 } else if(!strncmp(arg, "ntsc-", 5)) {
3518 } else if(!strncmp(arg, "film-", 5)) {
3523 /* Calculate FR via float to avoid int overflow */
3524 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3527 } else if((fr == 29970) || (fr == 23976)) {
3530 /* Try to determine PAL/NTSC by peeking in the input files */
3531 if(nb_input_files) {
3533 for(j = 0; j < nb_input_files; j++) {
3534 for(i = 0; i < input_files[j]->nb_streams; i++) {
3535 AVCodecContext *c = input_files[j]->streams[i]->codec;
3536 if(c->codec_type != CODEC_TYPE_VIDEO)
3538 fr = c->time_base.den * 1000 / c->time_base.num;
3542 } else if((fr == 29970) || (fr == 23976)) {
3552 if(verbose && norm >= 0)
3553 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3557 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3558 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3559 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3563 if(!strcmp(arg, "vcd")) {
3565 opt_video_codec("mpeg1video");
3566 opt_audio_codec("mp2");
3569 opt_frame_size(norm ? "352x240" : "352x288");
3570 opt_frame_rate(frame_rates[norm]);
3571 opt_default("gop", norm ? "18" : "15");
3573 opt_default("b", "1150000");
3574 opt_default("maxrate", "1150000");
3575 opt_default("minrate", "1150000");
3576 opt_default("bufsize", "327680"); // 40*1024*8;
3578 audio_bit_rate = 224000;
3579 audio_sample_rate = 44100;
3581 opt_default("packetsize", "2324");
3582 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3584 /* We have to offset the PTS, so that it is consistent with the SCR.
3585 SCR starts at 36000, but the first two packs contain only padding
3586 and the first pack from the other stream, respectively, may also have
3587 been written before.
3588 So the real data starts at SCR 36000+3*1200. */
3589 mux_preload= (36000+3*1200) / 90000.0; //0.44
3590 } else if(!strcmp(arg, "svcd")) {
3592 opt_video_codec("mpeg2video");
3593 opt_audio_codec("mp2");
3596 opt_frame_size(norm ? "480x480" : "480x576");
3597 opt_frame_rate(frame_rates[norm]);
3598 opt_default("gop", norm ? "18" : "15");
3600 opt_default("b", "2040000");
3601 opt_default("maxrate", "2516000");
3602 opt_default("minrate", "0"); //1145000;
3603 opt_default("bufsize", "1835008"); //224*1024*8;
3604 opt_default("flags", "+SCAN_OFFSET");
3607 audio_bit_rate = 224000;
3608 audio_sample_rate = 44100;
3610 opt_default("packetsize", "2324");
3612 } else if(!strcmp(arg, "dvd")) {
3614 opt_video_codec("mpeg2video");
3615 opt_audio_codec("ac3");
3618 opt_frame_size(norm ? "720x480" : "720x576");
3619 opt_frame_rate(frame_rates[norm]);
3620 opt_default("gop", norm ? "18" : "15");
3622 opt_default("b", "6000000");
3623 opt_default("maxrate", "9000000");
3624 opt_default("minrate", "0"); //1500000;
3625 opt_default("bufsize", "1835008"); //224*1024*8;
3627 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3628 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3630 audio_bit_rate = 448000;
3631 audio_sample_rate = 48000;
3633 } else if(!strncmp(arg, "dv", 2)) {
3637 opt_frame_size(norm ? "720x480" : "720x576");
3638 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3639 (norm ? "yuv411p" : "yuv420p"));
3640 opt_frame_rate(frame_rates[norm]);
3642 audio_sample_rate = 48000;
3646 fprintf(stderr, "Unknown target: %s\n", arg);
3651 static void opt_video_bsf(const char *arg)
3653 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3654 AVBitStreamFilterContext **bsfp;
3657 fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3661 bsfp= &video_bitstream_filters;
3663 bsfp= &(*bsfp)->next;
3668 //FIXME avoid audio - video code duplication
3669 static void opt_audio_bsf(const char *arg)
3671 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3672 AVBitStreamFilterContext **bsfp;
3675 fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3679 bsfp= &audio_bitstream_filters;
3681 bsfp= &(*bsfp)->next;
3686 static void show_version(void)
3688 /* TODO: add function interface to avutil and avformat */
3689 fprintf(stderr, "ffmpeg " FFMPEG_VERSION "\n"
3693 LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3697 static int opt_default(const char *opt, const char *arg){
3698 AVOption *o= av_set_string(avctx_opts, opt, arg);
3700 o = av_set_string(avformat_opts, opt, arg);
3704 // 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));
3706 //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3707 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3708 opt_names[opt_name_count++]= o->name;
3710 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3711 /* disable generate of real time pts in ffm (need to be supressed anyway) */
3712 if(avctx_opts->flags & CODEC_FLAG_BITEXACT)
3716 if(avctx_opts->debug)
3717 av_log_set_level(AV_LOG_DEBUG);
3721 const OptionDef options[] = {
3723 { "L", 0, {(void*)show_license}, "show license" },
3724 { "h", 0, {(void*)show_help}, "show help" },
3725 { "version", 0, {(void*)show_version}, "show version" },
3726 { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3727 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3728 { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3729 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3730 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3731 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3732 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3733 { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3734 { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
3735 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3736 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3737 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3738 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3739 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3740 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3741 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3742 { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3743 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3744 "add timings for benchmarking" },
3745 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3746 "dump each input packet" },
3747 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3748 "when dumping packets, also dump the payload" },
3749 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3750 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3751 { "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)", "" },
3752 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3753 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3754 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3755 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3756 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3757 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3758 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3759 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3760 { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3763 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3764 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3765 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3766 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3767 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3768 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3769 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3770 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3771 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3772 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3773 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3774 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3775 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3776 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3777 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3778 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3779 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3780 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3781 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3782 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
3783 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
3784 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3785 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3786 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3787 { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3789 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
3790 { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
3791 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3792 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3793 "use same video quality as source (implies VBR)" },
3794 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3795 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3796 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3797 "deinterlace pictures" },
3798 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3799 { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
3800 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3801 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3802 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3803 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3804 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3805 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3806 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3807 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3810 { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
3811 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3812 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3813 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3814 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3815 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3816 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3817 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3818 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3819 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3821 /* subtitle options */
3822 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3823 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3824 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3827 { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
3828 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3829 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3830 { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
3832 /* G.2 grab options */
3833 { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
3834 { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
3837 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3838 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3840 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
3841 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
3843 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3847 static void show_banner(void)
3849 fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2004 Fabrice Bellard\n");
3850 fprintf(stderr, " configuration: " FFMPEG_CONFIGURATION "\n");
3851 fprintf(stderr, " libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
3852 fprintf(stderr, " libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
3853 fprintf(stderr, " libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
3854 fprintf(stderr, " built on " __DATE__ " " __TIME__);
3856 fprintf(stderr, ", gcc: " __VERSION__ "\n");
3858 fprintf(stderr, ", using a non-gcc compiler\n");
3862 static void show_license(void)
3867 "This program is free software; you can redistribute it and/or modify\n"
3868 "it under the terms of the GNU General Public License as published by\n"
3869 "the Free Software Foundation; either version 2 of the License, or\n"
3870 "(at your option) any later version.\n"
3872 "This program is distributed in the hope that it will be useful,\n"
3873 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3874 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
3875 "GNU General Public License for more details.\n"
3877 "You should have received a copy of the GNU General Public License\n"
3878 "along with this program; if not, write to the Free Software\n"
3879 "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
3883 "This library is free software; you can redistribute it and/or\n"
3884 "modify it under the terms of the GNU Lesser General Public\n"
3885 "License as published by the Free Software Foundation; either\n"
3886 "version 2 of the License, or (at your option) any later version.\n"
3888 "This library is distributed in the hope that it will be useful,\n"
3889 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3890 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
3891 "Lesser General Public License for more details.\n"
3893 "You should have received a copy of the GNU Lesser General Public\n"
3894 "License along with this library; if not, write to the Free Software\n"
3895 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
3901 static void show_help(void)
3904 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3905 "Hyper fast Audio and Video encoder\n");
3907 show_help_options(options, "Main options:\n",
3908 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3909 show_help_options(options, "\nVideo options:\n",
3910 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3912 show_help_options(options, "\nAdvanced Video options:\n",
3913 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3914 OPT_VIDEO | OPT_EXPERT);
3915 show_help_options(options, "\nAudio options:\n",
3916 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3918 show_help_options(options, "\nAdvanced Audio options:\n",
3919 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3920 OPT_AUDIO | OPT_EXPERT);
3921 show_help_options(options, "\nSubtitle options:\n",
3922 OPT_SUBTITLE | OPT_GRAB,
3924 show_help_options(options, "\nAudio/Video grab options:\n",
3927 show_help_options(options, "\nAdvanced options:\n",
3928 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3930 av_opt_show(avctx_opts, NULL);
3931 av_opt_show(avformat_opts, NULL);
3936 void parse_arg_file(const char *filename)
3938 opt_output_file(filename);
3941 int main(int argc, char **argv)
3948 avctx_opts= avcodec_alloc_context();
3949 avformat_opts = av_alloc_format_context();
3957 parse_options(argc, argv, options);
3959 /* file converter / grab */
3960 if (nb_output_files <= 0) {
3961 fprintf(stderr, "Must supply at least one output file\n");
3965 if (nb_input_files == 0) {
3971 av_encode(output_files, nb_output_files, input_files, nb_input_files,
3972 stream_maps, nb_stream_maps);
3973 ti = getutime() - ti;
3975 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3979 for(i=0;i<nb_output_files;i++) {
3980 /* maybe av_close_output_file ??? */
3981 AVFormatContext *s = output_files[i];
3983 if (!(s->oformat->flags & AVFMT_NOFILE))
3985 for(j=0;j<s->nb_streams;j++)
3986 av_free(s->streams[j]);
3989 for(i=0;i<nb_input_files;i++)
3990 av_close_input_file(input_files[i]);
3995 av_free(intra_matrix);
3997 av_free(inter_matrix);
3999 #ifdef POWERPC_PERFORMANCE_REPORT
4000 extern void powerpc_display_perf_report(void);
4001 powerpc_display_perf_report();
4002 #endif /* POWERPC_PERFORMANCE_REPORT */
4005 if (received_sigterm) {
4007 "Received signal %d: terminating.\n",
4008 (int) received_sigterm);
4012 exit(0); /* not all OS-es handle main() return value */