3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 #define HAVE_AV_CONFIG_H
26 #include "framehook.h"
36 #include <sys/ioctl.h>
39 #include <sys/resource.h>
42 #include <sys/types.h>
43 #include <sys/select.h>
46 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
55 #if !defined(INFINITY) && defined(HUGE_VAL)
56 #define INFINITY HUGE_VAL
59 /* select an input stream for an output stream */
60 typedef struct AVStreamMap {
64 int sync_stream_index;
67 /** select an input file for an output file */
68 typedef struct AVMetaDataMap {
73 extern const OptionDef options[];
75 static void show_help(void);
76 static void show_license(void);
77 static int opt_default(const char *opt, const char *arg);
81 static AVFormatContext *input_files[MAX_FILES];
82 static int64_t input_files_ts_offset[MAX_FILES];
83 static int nb_input_files = 0;
85 static AVFormatContext *output_files[MAX_FILES];
86 static int nb_output_files = 0;
88 static AVStreamMap stream_maps[MAX_FILES];
89 static int nb_stream_maps;
91 static AVMetaDataMap meta_data_maps[MAX_FILES];
92 static int nb_meta_data_maps;
94 static AVInputFormat *file_iformat;
95 static AVOutputFormat *file_oformat;
96 static int frame_width = 0;
97 static int frame_height = 0;
98 static float frame_aspect_ratio = 0;
99 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
100 static int frame_padtop = 0;
101 static int frame_padbottom = 0;
102 static int frame_padleft = 0;
103 static int frame_padright = 0;
104 static int padcolor[3] = {16,128,128}; /* default to black */
105 static int frame_topBand = 0;
106 static int frame_bottomBand = 0;
107 static int frame_leftBand = 0;
108 static int frame_rightBand = 0;
109 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
110 static int frame_rate = 25;
111 static int frame_rate_base = 1;
112 static float video_qscale = 0;
113 static int video_qdiff = 3;
114 static uint16_t *intra_matrix = NULL;
115 static uint16_t *inter_matrix = NULL;
116 #if 0 //experimental, (can be removed)
117 static float video_rc_qsquish=1.0;
118 static float video_rc_qmod_amp=0;
119 static int video_rc_qmod_freq=0;
121 static char *video_rc_override_string=NULL;
122 static char *video_rc_eq="tex^qComp";
123 static int me_method = ME_EPZS;
124 static int video_disable = 0;
125 static int video_discard = 0;
126 static int video_codec_id = CODEC_ID_NONE;
127 static int video_codec_tag = 0;
128 static int same_quality = 0;
129 static int do_deinterlace = 0;
130 static int packet_size = 0;
131 static int strict = 0;
132 static int top_field_first = -1;
133 static int me_threshold = 0;
134 static int intra_dc_precision = 8;
135 static int loop_input = 0;
136 static int loop_output = AVFMT_NOOUTPUTLOOP;
137 static int qp_hist = 0;
139 static int intra_only = 0;
140 static int audio_sample_rate = 44100;
141 static int audio_bit_rate = 64000;
142 #define QSCALE_NONE -99999
143 static float audio_qscale = QSCALE_NONE;
144 static int audio_disable = 0;
145 static int audio_channels = 1;
146 static int audio_codec_id = CODEC_ID_NONE;
147 static int audio_codec_tag = 0;
148 static char *audio_language = NULL;
150 static int subtitle_codec_id = CODEC_ID_NONE;
151 static char *subtitle_language = NULL;
153 static float mux_preload= 0.5;
154 static float mux_max_delay= 0.7;
156 static int64_t recording_time = 0;
157 static int64_t start_time = 0;
158 static int64_t rec_timestamp = 0;
159 static int64_t input_ts_offset = 0;
160 static int file_overwrite = 0;
161 static char *str_title = NULL;
162 static char *str_author = NULL;
163 static char *str_copyright = NULL;
164 static char *str_comment = NULL;
165 static char *str_album = NULL;
166 static int do_benchmark = 0;
167 static int do_hex_dump = 0;
168 static int do_pkt_dump = 0;
169 static int do_psnr = 0;
170 static int do_vstats = 0;
171 static int do_pass = 0;
172 static char *pass_logfilename = NULL;
173 static int audio_stream_copy = 0;
174 static int video_stream_copy = 0;
175 static int subtitle_stream_copy = 0;
176 static int video_sync_method= 1;
177 static int audio_sync_method= 0;
178 static int copy_ts= 0;
179 static int opt_shortest = 0; //
180 static int video_global_header = 0;
182 static int rate_emu = 0;
185 static const char *video_grab_format = "bktr";
187 #ifdef CONFIG_VIDEO4LINUX2
188 static const char *video_grab_format = "video4linux2";
190 static const char *video_grab_format = "video4linux";
193 static char *video_device = NULL;
194 static char *grab_device = NULL;
195 static int video_channel = 0;
196 static char *video_standard = "ntsc";
198 static const char *audio_grab_format = "audio_device";
199 static char *audio_device = NULL;
200 static int audio_volume = 256;
202 static int using_stdin = 0;
203 static int using_vhook = 0;
204 static int verbose = 1;
205 static int thread_count= 1;
206 static int q_pressed = 0;
207 static int64_t video_size = 0;
208 static int64_t audio_size = 0;
209 static int64_t extra_size = 0;
210 static int nb_frames_dup = 0;
211 static int nb_frames_drop = 0;
212 static int input_sync;
213 static int limit_filesize = 0; //
215 static int pgmyuv_compatibility_hack=0;
216 static int dts_delta_threshold = 10;
218 static int sws_flags = SWS_BICUBIC;
220 const char **opt_names=NULL;
221 int opt_name_count=0;
222 AVCodecContext *avctx_opts;
223 AVFormatContext *avformat_opts;
225 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
226 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
227 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
229 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
231 struct AVInputStream;
233 typedef struct AVOutputStream {
234 int file_index; /* file index */
235 int index; /* stream index in the output file */
236 int source_index; /* AVInputStream index */
237 AVStream *st; /* stream in the output file */
238 int encoding_needed; /* true if encoding needed for this stream */
240 /* input pts and corresponding output pts
242 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
243 struct AVInputStream *sync_ist; /* input stream to sync against */
244 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
247 AVFrame pict_tmp; /* temporary image for resampling */
248 struct SwsContext *img_resample_ctx; /* for image resampling */
252 int topBand; /* cropping area sizes */
256 int padtop; /* padding area sizes */
263 ReSampleContext *resample; /* for audio resampling */
264 AVFifoBuffer fifo; /* for compression: one audio fifo per codec */
268 typedef struct AVInputStream {
272 int discard; /* true if stream data should be discarded */
273 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
274 int64_t sample_index; /* current sample */
276 int64_t start; /* time when read started */
277 unsigned long frame; /* current frame */
278 int64_t next_pts; /* synthetic pts for cases where pkt.pts
280 int64_t pts; /* current pts */
281 int is_start; /* is 1 at the start and after a discontinuity */
284 typedef struct AVInputFile {
285 int eof_reached; /* true if eof reached */
286 int ist_index; /* index of first stream in ist_table */
287 int buffer_size; /* current total buffer size */
288 int buffer_size_max; /* buffer size at which we consider we can stop
290 int nb_streams; /* nb streams we are aware of */
295 /* init terminal so that we can grab keys */
296 static struct termios oldtty;
299 static void term_exit(void)
302 tcsetattr (0, TCSANOW, &oldtty);
306 static volatile sig_atomic_t received_sigterm = 0;
309 sigterm_handler(int sig)
311 received_sigterm = sig;
315 static void term_init(void)
323 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
324 |INLCR|IGNCR|ICRNL|IXON);
325 tty.c_oflag |= OPOST;
326 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
327 tty.c_cflag &= ~(CSIZE|PARENB);
332 tcsetattr (0, TCSANOW, &tty);
333 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
336 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
337 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
339 register a function to be called at normal program termination
342 #ifdef CONFIG_BEOS_NETSERVER
343 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
347 /* read a key without blocking */
348 static int read_key(void)
356 #ifndef CONFIG_BEOS_NETSERVER
364 n = select(1, &rfds, NULL, NULL, &tv);
377 static int decode_interrupt_cb(void)
379 return q_pressed || (q_pressed = read_key() == 'q');
382 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
387 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
390 /* copy stream format */
391 s->nb_streams = ic->nb_streams;
392 for(i=0;i<ic->nb_streams;i++) {
395 // FIXME: a more elegant solution is needed
396 st = av_mallocz(sizeof(AVStream));
397 memcpy(st, ic->streams[i], sizeof(AVStream));
398 st->codec = avcodec_alloc_context();
399 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
403 av_close_input_file(ic);
408 get_sync_ipts(const AVOutputStream *ost)
410 const AVInputStream *ist = ost->sync_ist;
411 return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
414 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
416 AVPacket new_pkt= *pkt;
417 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
418 &new_pkt.data, &new_pkt.size,
419 pkt->data, pkt->size,
420 pkt->flags & PKT_FLAG_KEY);
423 new_pkt.destruct= av_destruct_packet;
430 av_interleaved_write_frame(s, pkt);
433 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
435 static void do_audio_out(AVFormatContext *s,
438 unsigned char *buf, int size)
441 static uint8_t *audio_buf = NULL;
442 static uint8_t *audio_out = NULL;
443 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
445 int size_out, frame_bytes, ret;
446 AVCodecContext *enc= ost->st->codec;
448 /* SC: dynamic allocation of buffers */
450 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
452 audio_out = av_malloc(audio_out_size);
453 if (!audio_buf || !audio_out)
454 return; /* Should signal an error ! */
456 if(audio_sync_method){
457 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
458 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
459 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
460 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
462 //FIXME resample delay
463 if(fabs(delta) > 50){
466 byte_delta= FFMAX(byte_delta, -size);
470 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
475 static uint8_t *input_tmp= NULL;
476 input_tmp= av_realloc(input_tmp, byte_delta + size);
478 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
481 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
483 memset(input_tmp, 0, byte_delta);
484 memcpy(input_tmp + byte_delta, buf, size);
488 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
490 }else if(audio_sync_method>1){
491 int comp= clip(delta, -audio_sync_method, audio_sync_method);
492 assert(ost->audio_resample);
494 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
495 // fprintf(stderr, "drift:%f len:%d opts:%"PRId64" ipts:%"PRId64" 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));
496 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
500 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
501 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
503 if (ost->audio_resample) {
505 size_out = audio_resample(ost->resample,
506 (short *)buftmp, (short *)buf,
507 size / (ist->st->codec->channels * 2));
508 size_out = size_out * enc->channels * 2;
514 /* now encode as many frames as possible */
515 if (enc->frame_size > 1) {
516 /* output resampled raw samples */
517 av_fifo_write(&ost->fifo, buftmp, size_out);
519 frame_bytes = enc->frame_size * 2 * enc->channels;
521 while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
523 av_init_packet(&pkt);
525 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
528 pkt.stream_index= ost->index;
531 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
532 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
533 pkt.flags |= PKT_FLAG_KEY;
534 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
536 ost->sync_opts += enc->frame_size;
540 av_init_packet(&pkt);
542 ost->sync_opts += size_out / (2 * enc->channels);
544 /* output a pcm frame */
545 /* XXX: change encoding codec API to avoid this ? */
546 switch(enc->codec->id) {
547 case CODEC_ID_PCM_S32LE:
548 case CODEC_ID_PCM_S32BE:
549 case CODEC_ID_PCM_U32LE:
550 case CODEC_ID_PCM_U32BE:
551 size_out = size_out << 1;
553 case CODEC_ID_PCM_S24LE:
554 case CODEC_ID_PCM_S24BE:
555 case CODEC_ID_PCM_U24LE:
556 case CODEC_ID_PCM_U24BE:
557 case CODEC_ID_PCM_S24DAUD:
558 size_out = size_out / 2 * 3;
560 case CODEC_ID_PCM_S16LE:
561 case CODEC_ID_PCM_S16BE:
562 case CODEC_ID_PCM_U16LE:
563 case CODEC_ID_PCM_U16BE:
566 size_out = size_out >> 1;
569 ret = avcodec_encode_audio(enc, audio_out, size_out,
572 pkt.stream_index= ost->index;
575 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
576 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
577 pkt.flags |= PKT_FLAG_KEY;
578 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
582 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
586 AVPicture picture_tmp;
589 dec = ist->st->codec;
591 /* deinterlace : must be done before any resize */
592 if (do_deinterlace || using_vhook) {
595 /* create temporary picture */
596 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
597 buf = av_malloc(size);
601 picture2 = &picture_tmp;
602 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
605 if(avpicture_deinterlace(picture2, picture,
606 dec->pix_fmt, dec->width, dec->height) < 0) {
607 /* if error, do not deinterlace */
613 img_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
619 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
621 if (picture != picture2)
622 *picture = *picture2;
626 /* we begin to correct av delay at this threshold */
627 #define AV_DELAY_MAX 0.100
629 static void do_subtitle_out(AVFormatContext *s,
635 static uint8_t *subtitle_out = NULL;
636 int subtitle_out_max_size = 65536;
637 int subtitle_out_size, nb, i;
641 if (pts == AV_NOPTS_VALUE) {
642 fprintf(stderr, "Subtitle packets must have a pts\n");
646 enc = ost->st->codec;
649 subtitle_out = av_malloc(subtitle_out_max_size);
652 /* Note: DVB subtitle need one packet to draw them and one other
653 packet to clear them */
654 /* XXX: signal it in the codec context ? */
655 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
660 for(i = 0; i < nb; i++) {
661 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
662 subtitle_out_max_size, sub);
664 av_init_packet(&pkt);
665 pkt.stream_index = ost->index;
666 pkt.data = subtitle_out;
667 pkt.size = subtitle_out_size;
668 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);
669 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
670 /* XXX: the pts correction is handled here. Maybe handling
671 it in the codec would be better */
673 pkt.pts += 90 * sub->start_display_time;
675 pkt.pts += 90 * sub->end_display_time;
677 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
681 static int bit_buffer_size= 1024*256;
682 static uint8_t *bit_buffer= NULL;
684 static void do_video_out(AVFormatContext *s,
690 int nb_frames, i, ret;
691 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
692 AVFrame picture_crop_temp, picture_pad_temp;
693 uint8_t *buf = NULL, *buf1 = NULL;
694 AVCodecContext *enc, *dec;
696 avcodec_get_frame_defaults(&picture_crop_temp);
697 avcodec_get_frame_defaults(&picture_pad_temp);
699 enc = ost->st->codec;
700 dec = ist->st->codec;
702 /* by default, we output a single frame */
707 if(video_sync_method){
709 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
710 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
713 else if (vdelta > 1.1)
714 nb_frames = lrintf(vdelta);
715 //fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, ost->sync_ipts, nb_frames);
719 fprintf(stderr, "*** drop!\n");
720 }else if (nb_frames > 1) {
721 nb_frames_dup += nb_frames;
723 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
726 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
728 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
732 if (ost->video_crop) {
733 if (img_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
734 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
737 formatted_picture = &picture_crop_temp;
739 formatted_picture = in_picture;
742 final_picture = formatted_picture;
743 padding_src = formatted_picture;
744 resampling_dst = &ost->pict_tmp;
745 if (ost->video_pad) {
746 final_picture = &ost->pict_tmp;
747 if (ost->video_resample) {
748 if (img_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
749 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
752 resampling_dst = &picture_pad_temp;
756 if (ost->video_resample) {
758 final_picture = &ost->pict_tmp;
759 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
760 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
763 if (ost->video_pad) {
764 img_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
765 enc->height, enc->width, enc->pix_fmt,
766 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
769 /* duplicates frame if needed */
770 for(i=0;i<nb_frames;i++) {
772 av_init_packet(&pkt);
773 pkt.stream_index= ost->index;
775 if (s->oformat->flags & AVFMT_RAWPICTURE) {
776 /* raw pictures are written as AVPicture structure to
777 avoid any copies. We support temorarily the older
779 AVFrame* old_frame = enc->coded_frame;
780 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
781 pkt.data= (uint8_t *)final_picture;
782 pkt.size= sizeof(AVPicture);
783 if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
784 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
785 if(dec->coded_frame && dec->coded_frame->key_frame)
786 pkt.flags |= PKT_FLAG_KEY;
788 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
789 enc->coded_frame = old_frame;
793 big_picture= *final_picture;
794 /* better than nothing: use input picture interlaced
796 big_picture.interlaced_frame = in_picture->interlaced_frame;
797 if(avctx_opts->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
798 if(top_field_first == -1)
799 big_picture.top_field_first = in_picture->top_field_first;
801 big_picture.top_field_first = top_field_first;
804 /* handles sameq here. This is not correct because it may
805 not be a global option */
807 big_picture.quality = ist->st->quality;
809 big_picture.quality = ost->st->quality;
811 big_picture.pict_type = 0;
812 // big_picture.pts = AV_NOPTS_VALUE;
813 big_picture.pts= ost->sync_opts;
814 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
815 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
816 ret = avcodec_encode_video(enc,
817 bit_buffer, bit_buffer_size,
820 fprintf(stderr, "Video encoding failed\n");
823 //enc->frame_number = enc->real_pict_num;
825 pkt.data= bit_buffer;
827 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
828 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
829 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
830 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
831 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
833 if(enc->coded_frame && enc->coded_frame->key_frame)
834 pkt.flags |= PKT_FLAG_KEY;
835 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
837 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
838 // enc->frame_number-1, enc->real_pict_num, ret,
840 /* if two pass, output log */
841 if (ost->logfile && enc->stats_out) {
842 fprintf(ost->logfile, "%s", enc->stats_out);
854 static double psnr(double d){
855 if(d==0) return INFINITY;
856 return -10.0*log(d)/log(10.0);
859 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
862 static FILE *fvstats=NULL;
869 double ti1, bitrate, avg_bitrate;
873 today = localtime(&today2);
874 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
877 fvstats = fopen(filename,"w");
885 enc = ost->st->codec;
886 if (enc->codec_type == CODEC_TYPE_VIDEO) {
887 frame_number = ost->frame_number;
888 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
889 if (enc->flags&CODEC_FLAG_PSNR)
890 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
892 fprintf(fvstats,"f_size= %6d ", frame_size);
893 /* compute pts value */
894 ti1 = ost->sync_opts * av_q2d(enc->time_base);
898 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
899 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
900 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
901 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
902 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
906 static void print_report(AVFormatContext **output_files,
907 AVOutputStream **ost_table, int nb_ostreams,
912 AVFormatContext *oc, *os;
915 int frame_number, vid, i;
916 double bitrate, ti1, pts;
917 static int64_t last_time = -1;
918 static int qp_histogram[52];
920 if (!is_last_report) {
922 /* display the report every 0.5 seconds */
923 cur_time = av_gettime();
924 if (last_time == -1) {
925 last_time = cur_time;
928 if ((cur_time - last_time) < 500000)
930 last_time = cur_time;
934 oc = output_files[0];
936 total_size = url_ftell(&oc->pb);
941 for(i=0;i<nb_ostreams;i++) {
943 os = output_files[ost->file_index];
944 enc = ost->st->codec;
945 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
946 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
947 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
949 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
950 frame_number = ost->frame_number;
951 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%3.1f ",
952 frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
954 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
955 if(qp_hist && enc->coded_frame){
957 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
958 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
961 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
963 if (enc->flags&CODEC_FLAG_PSNR){
965 double error, error_sum=0;
966 double scale, scale_sum=0;
967 char type[3]= {'Y','U','V'};
968 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
971 error= enc->error[j];
972 scale= enc->width*enc->height*255.0*255.0*frame_number;
974 error= enc->coded_frame->error[j];
975 scale= enc->width*enc->height*255.0*255.0;
980 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
982 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
986 /* compute min output value */
987 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
988 if ((pts < ti1) && (pts > 0))
994 if (verbose || is_last_report) {
995 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
997 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
998 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
999 (double)total_size / 1024, ti1, bitrate);
1002 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1003 nb_frames_dup, nb_frames_drop);
1006 fprintf(stderr, "%s \r", buf);
1011 if (is_last_report && verbose >= 0){
1012 int64_t raw= audio_size + video_size + extra_size;
1013 fprintf(stderr, "\n");
1014 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1018 100.0*(total_size - raw)/raw
1023 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1024 static int output_packet(AVInputStream *ist, int ist_index,
1025 AVOutputStream **ost_table, int nb_ostreams,
1026 const AVPacket *pkt)
1028 AVFormatContext *os;
1029 AVOutputStream *ost;
1033 int data_size, got_picture;
1035 void *buffer_to_free;
1036 static unsigned int samples_size= 0;
1037 static short *samples= NULL;
1038 AVSubtitle subtitle, *subtitle_to_free;
1042 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1043 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1044 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1046 // assert(ist->pts == ist->next_pts);
1060 /* decode the packet if needed */
1061 data_buf = NULL; /* fail safe */
1063 subtitle_to_free = NULL;
1064 if (ist->decoding_needed) {
1065 switch(ist->st->codec->codec_type) {
1066 case CODEC_TYPE_AUDIO:{
1068 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1069 data_size= samples_size;
1070 /* XXX: could avoid copy if PCM 16 bits with same
1071 endianness as CPU */
1072 ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1078 /* Some bug in mpeg audio decoder gives */
1079 /* data_size < 0, it seems they are overflows */
1080 if (data_size <= 0) {
1081 /* no audio frame */
1084 data_buf = (uint8_t *)samples;
1085 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1086 (ist->st->codec->sample_rate * ist->st->codec->channels);
1088 case CODEC_TYPE_VIDEO:
1089 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1090 /* XXX: allocate picture correctly */
1091 avcodec_get_frame_defaults(&picture);
1093 ret = avcodec_decode_video(ist->st->codec,
1094 &picture, &got_picture, ptr, len);
1095 ist->st->quality= picture.quality;
1099 /* no picture yet */
1100 goto discard_packet;
1102 if (ist->st->codec->time_base.num != 0) {
1103 ist->next_pts += ((int64_t)AV_TIME_BASE *
1104 ist->st->codec->time_base.num) /
1105 ist->st->codec->time_base.den;
1109 case CODEC_TYPE_SUBTITLE:
1110 ret = avcodec_decode_subtitle(ist->st->codec,
1111 &subtitle, &got_subtitle, ptr, len);
1114 if (!got_subtitle) {
1115 goto discard_packet;
1117 subtitle_to_free = &subtitle;
1124 switch(ist->st->codec->codec_type) {
1125 case CODEC_TYPE_AUDIO:
1126 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1127 (ist->st->codec->sample_rate * ist->st->codec->channels);
1129 case CODEC_TYPE_VIDEO:
1130 if (ist->st->codec->time_base.num != 0) {
1131 ist->next_pts += ((int64_t)AV_TIME_BASE *
1132 ist->st->codec->time_base.num) /
1133 ist->st->codec->time_base.den;
1143 buffer_to_free = NULL;
1144 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1145 pre_process_video_frame(ist, (AVPicture *)&picture,
1149 // preprocess audio (volume)
1150 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1151 if (audio_volume != 256) {
1154 for(i=0;i<(data_size / sizeof(short));i++) {
1155 int v = ((*volp) * audio_volume + 128) >> 8;
1156 if (v < -32768) v = -32768;
1157 if (v > 32767) v = 32767;
1163 /* frame rate emulation */
1164 if (ist->st->codec->rate_emu) {
1165 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1166 int64_t now = av_gettime() - ist->start;
1174 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1175 is the one of the next displayed one */
1176 /* XXX: add mpeg4 too ? */
1177 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1178 if (ist->st->codec->pict_type != B_TYPE) {
1180 tmp = ist->last_ip_pts;
1181 ist->last_ip_pts = ist->frac_pts.val;
1182 ist->frac_pts.val = tmp;
1186 /* if output time reached then transcode raw format,
1187 encode packets and output them */
1188 if (start_time == 0 || ist->pts >= start_time)
1189 for(i=0;i<nb_ostreams;i++) {
1193 if (ost->source_index == ist_index) {
1194 os = output_files[ost->file_index];
1197 printf("%d: got pts=%0.3f %0.3f\n", i,
1198 (double)pkt->pts / AV_TIME_BASE,
1199 ((double)ist->pts / AV_TIME_BASE) -
1200 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1202 /* set the input output pts pairs */
1203 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1205 if (ost->encoding_needed) {
1206 switch(ost->st->codec->codec_type) {
1207 case CODEC_TYPE_AUDIO:
1208 do_audio_out(os, ost, ist, data_buf, data_size);
1210 case CODEC_TYPE_VIDEO:
1211 do_video_out(os, ost, ist, &picture, &frame_size);
1212 video_size += frame_size;
1213 if (do_vstats && frame_size)
1214 do_video_stats(os, ost, frame_size);
1216 case CODEC_TYPE_SUBTITLE:
1217 do_subtitle_out(os, ost, ist, &subtitle,
1224 AVFrame avframe; //FIXME/XXX remove this
1226 av_init_packet(&opkt);
1228 /* no reencoding needed : output the packet directly */
1229 /* force the input stream PTS */
1231 avcodec_get_frame_defaults(&avframe);
1232 ost->st->codec->coded_frame= &avframe;
1233 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1235 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1236 audio_size += data_size;
1237 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1238 video_size += data_size;
1242 opkt.stream_index= ost->index;
1243 if(pkt->pts != AV_NOPTS_VALUE)
1244 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);
1246 opkt.pts= AV_NOPTS_VALUE;
1250 if (pkt->dts == AV_NOPTS_VALUE)
1251 dts = ist->next_pts;
1253 dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1254 opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
1256 opkt.flags= pkt->flags;
1258 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1259 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1260 opkt.destruct= av_destruct_packet;
1262 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1263 ost->st->codec->frame_number++;
1264 ost->frame_number++;
1265 av_free_packet(&opkt);
1269 av_free(buffer_to_free);
1270 /* XXX: allocate the subtitles in the codec ? */
1271 if (subtitle_to_free) {
1272 if (subtitle_to_free->rects != NULL) {
1273 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1274 av_free(subtitle_to_free->rects[i].bitmap);
1275 av_free(subtitle_to_free->rects[i].rgba_palette);
1277 av_freep(&subtitle_to_free->rects);
1279 subtitle_to_free->num_rects = 0;
1280 subtitle_to_free = NULL;
1287 for(i=0;i<nb_ostreams;i++) {
1289 if (ost->source_index == ist_index) {
1290 AVCodecContext *enc= ost->st->codec;
1291 os = output_files[ost->file_index];
1293 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1295 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1298 if (ost->encoding_needed) {
1302 av_init_packet(&pkt);
1303 pkt.stream_index= ost->index;
1305 switch(ost->st->codec->codec_type) {
1306 case CODEC_TYPE_AUDIO:
1307 fifo_bytes = av_fifo_size(&ost->fifo);
1309 /* encode any samples remaining in fifo */
1310 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1311 int fs_tmp = enc->frame_size;
1312 enc->frame_size = fifo_bytes / (2 * enc->channels);
1313 if(av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes) == 0) {
1314 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1316 enc->frame_size = fs_tmp;
1319 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1322 pkt.flags |= PKT_FLAG_KEY;
1324 case CODEC_TYPE_VIDEO:
1325 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1327 if(enc->coded_frame && enc->coded_frame->key_frame)
1328 pkt.flags |= PKT_FLAG_KEY;
1329 if (ost->logfile && enc->stats_out) {
1330 fprintf(ost->logfile, "%s", enc->stats_out);
1339 pkt.data= bit_buffer;
1341 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1342 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1343 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1357 * The following code is the main loop of the file converter
1359 static int av_encode(AVFormatContext **output_files,
1360 int nb_output_files,
1361 AVFormatContext **input_files,
1363 AVStreamMap *stream_maps, int nb_stream_maps)
1365 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1366 AVFormatContext *is, *os;
1367 AVCodecContext *codec, *icodec;
1368 AVOutputStream *ost, **ost_table = NULL;
1369 AVInputStream *ist, **ist_table = NULL;
1370 AVInputFile *file_table;
1371 AVFormatContext *stream_no_data;
1374 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1378 /* input stream init */
1380 for(i=0;i<nb_input_files;i++) {
1381 is = input_files[i];
1382 file_table[i].ist_index = j;
1383 file_table[i].nb_streams = is->nb_streams;
1384 j += is->nb_streams;
1388 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1392 for(i=0;i<nb_istreams;i++) {
1393 ist = av_mallocz(sizeof(AVInputStream));
1399 for(i=0;i<nb_input_files;i++) {
1400 is = input_files[i];
1401 for(k=0;k<is->nb_streams;k++) {
1402 ist = ist_table[j++];
1403 ist->st = is->streams[k];
1404 ist->file_index = i;
1406 ist->discard = 1; /* the stream is discarded by default
1409 if (ist->st->codec->rate_emu) {
1410 ist->start = av_gettime();
1416 /* output stream init */
1418 for(i=0;i<nb_output_files;i++) {
1419 os = output_files[i];
1420 if (!os->nb_streams) {
1421 fprintf(stderr, "Output file does not contain any stream\n");
1424 nb_ostreams += os->nb_streams;
1426 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1427 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1431 /* Sanity check the mapping args -- do the input files & streams exist? */
1432 for(i=0;i<nb_stream_maps;i++) {
1433 int fi = stream_maps[i].file_index;
1434 int si = stream_maps[i].stream_index;
1436 if (fi < 0 || fi > nb_input_files - 1 ||
1437 si < 0 || si > file_table[fi].nb_streams - 1) {
1438 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1441 fi = stream_maps[i].sync_file_index;
1442 si = stream_maps[i].sync_stream_index;
1443 if (fi < 0 || fi > nb_input_files - 1 ||
1444 si < 0 || si > file_table[fi].nb_streams - 1) {
1445 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1450 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1453 for(i=0;i<nb_ostreams;i++) {
1454 ost = av_mallocz(sizeof(AVOutputStream));
1461 for(k=0;k<nb_output_files;k++) {
1462 os = output_files[k];
1463 for(i=0;i<os->nb_streams;i++) {
1465 ost = ost_table[n++];
1466 ost->file_index = k;
1468 ost->st = os->streams[i];
1469 if (nb_stream_maps > 0) {
1470 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1471 stream_maps[n-1].stream_index;
1473 /* Sanity check that the stream types match */
1474 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1475 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1476 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1477 ost->file_index, ost->index);
1482 /* get corresponding input stream index : we select the first one with the right type */
1484 for(j=0;j<nb_istreams;j++) {
1487 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1488 ost->source_index = j;
1495 /* try again and reuse existing stream */
1496 for(j=0;j<nb_istreams;j++) {
1498 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1499 ost->source_index = j;
1504 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1505 ost->file_index, ost->index);
1510 ist = ist_table[ost->source_index];
1512 ost->sync_ist = (nb_stream_maps > 0) ?
1513 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1514 stream_maps[n-1].sync_stream_index] : ist;
1518 /* for each output stream, we compute the right encoding parameters */
1519 for(i=0;i<nb_ostreams;i++) {
1521 ist = ist_table[ost->source_index];
1523 codec = ost->st->codec;
1524 icodec = ist->st->codec;
1526 if (ost->st->stream_copy) {
1527 /* if stream_copy is selected, no need to decode or encode */
1528 codec->codec_id = icodec->codec_id;
1529 codec->codec_type = icodec->codec_type;
1530 if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1531 codec->bit_rate = icodec->bit_rate;
1532 codec->extradata= icodec->extradata;
1533 codec->extradata_size= icodec->extradata_size;
1534 if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1535 codec->time_base = icodec->time_base;
1537 codec->time_base = ist->st->time_base;
1538 switch(codec->codec_type) {
1539 case CODEC_TYPE_AUDIO:
1540 codec->sample_rate = icodec->sample_rate;
1541 codec->channels = icodec->channels;
1542 codec->frame_size = icodec->frame_size;
1543 codec->block_align= icodec->block_align;
1545 case CODEC_TYPE_VIDEO:
1546 codec->pix_fmt = icodec->pix_fmt;
1547 codec->width = icodec->width;
1548 codec->height = icodec->height;
1549 codec->has_b_frames = icodec->has_b_frames;
1551 case CODEC_TYPE_SUBTITLE:
1557 switch(codec->codec_type) {
1558 case CODEC_TYPE_AUDIO:
1559 if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1562 if (codec->channels == icodec->channels &&
1563 codec->sample_rate == icodec->sample_rate) {
1564 ost->audio_resample = 0;
1566 if (codec->channels != icodec->channels &&
1567 (icodec->codec_id == CODEC_ID_AC3 ||
1568 icodec->codec_id == CODEC_ID_DTS)) {
1569 /* Special case for 5:1 AC3 and DTS input */
1570 /* and mono or stereo output */
1571 /* Request specific number of channels */
1572 icodec->channels = codec->channels;
1573 if (codec->sample_rate == icodec->sample_rate)
1574 ost->audio_resample = 0;
1576 ost->audio_resample = 1;
1579 ost->audio_resample = 1;
1582 if(audio_sync_method>1)
1583 ost->audio_resample = 1;
1585 if(ost->audio_resample){
1586 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1587 codec->sample_rate, icodec->sample_rate);
1589 printf("Can't resample. Aborting.\n");
1593 ist->decoding_needed = 1;
1594 ost->encoding_needed = 1;
1596 case CODEC_TYPE_VIDEO:
1597 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1598 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1599 ost->video_resample = ((codec->width != icodec->width -
1600 (frame_leftBand + frame_rightBand) +
1601 (frame_padleft + frame_padright)) ||
1602 (codec->height != icodec->height -
1603 (frame_topBand + frame_bottomBand) +
1604 (frame_padtop + frame_padbottom)) ||
1605 (codec->pix_fmt != icodec->pix_fmt));
1606 if (ost->video_crop) {
1607 ost->topBand = frame_topBand;
1608 ost->leftBand = frame_leftBand;
1610 if (ost->video_pad) {
1611 ost->padtop = frame_padtop;
1612 ost->padleft = frame_padleft;
1613 ost->padbottom = frame_padbottom;
1614 ost->padright = frame_padright;
1615 if (!ost->video_resample) {
1616 avcodec_get_frame_defaults(&ost->pict_tmp);
1617 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1618 codec->width, codec->height ) )
1622 if (ost->video_resample) {
1623 avcodec_get_frame_defaults(&ost->pict_tmp);
1624 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1625 codec->width, codec->height ) )
1628 ost->img_resample_ctx = sws_getContext(
1629 icodec->width - (frame_leftBand + frame_rightBand),
1630 icodec->height - (frame_topBand + frame_bottomBand),
1632 codec->width - (frame_padleft + frame_padright),
1633 codec->height - (frame_padtop + frame_padbottom),
1635 sws_flags, NULL, NULL, NULL);
1636 if (ost->img_resample_ctx == NULL) {
1637 fprintf(stderr, "Cannot get resampling context\n");
1640 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1642 ost->encoding_needed = 1;
1643 ist->decoding_needed = 1;
1645 case CODEC_TYPE_SUBTITLE:
1646 ost->encoding_needed = 1;
1647 ist->decoding_needed = 1;
1654 if (ost->encoding_needed &&
1655 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1656 char logfilename[1024];
1661 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1663 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1664 if (codec->flags & CODEC_FLAG_PASS1) {
1665 f = fopen(logfilename, "w");
1667 perror(logfilename);
1672 /* read the log file */
1673 f = fopen(logfilename, "r");
1675 perror(logfilename);
1678 fseek(f, 0, SEEK_END);
1680 fseek(f, 0, SEEK_SET);
1681 logbuffer = av_malloc(size + 1);
1683 fprintf(stderr, "Could not allocate log buffer\n");
1686 size = fread(logbuffer, 1, size, f);
1688 logbuffer[size] = '\0';
1689 codec->stats_in = logbuffer;
1693 if(codec->codec_type == CODEC_TYPE_VIDEO){
1694 int size= codec->width * codec->height;
1695 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1700 bit_buffer = av_malloc(bit_buffer_size);
1704 /* dump the file output parameters - cannot be done before in case
1706 for(i=0;i<nb_output_files;i++) {
1707 dump_format(output_files[i], i, output_files[i]->filename, 1);
1710 /* dump the stream mapping */
1712 fprintf(stderr, "Stream mapping:\n");
1713 for(i=0;i<nb_ostreams;i++) {
1715 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1716 ist_table[ost->source_index]->file_index,
1717 ist_table[ost->source_index]->index,
1720 if (ost->sync_ist != ist_table[ost->source_index])
1721 fprintf(stderr, " [sync #%d.%d]",
1722 ost->sync_ist->file_index,
1723 ost->sync_ist->index);
1724 fprintf(stderr, "\n");
1728 /* open each encoder */
1729 for(i=0;i<nb_ostreams;i++) {
1731 if (ost->encoding_needed) {
1733 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1735 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1736 ost->file_index, ost->index);
1739 if (avcodec_open(ost->st->codec, codec) < 0) {
1740 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1741 ost->file_index, ost->index);
1744 extra_size += ost->st->codec->extradata_size;
1748 /* open each decoder */
1749 for(i=0;i<nb_istreams;i++) {
1751 if (ist->decoding_needed) {
1753 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1755 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1756 ist->st->codec->codec_id, ist->file_index, ist->index);
1759 if (avcodec_open(ist->st->codec, codec) < 0) {
1760 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1761 ist->file_index, ist->index);
1764 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1765 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1770 for(i=0;i<nb_istreams;i++) {
1772 is = input_files[ist->file_index];
1774 ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1775 if(ist->st->start_time == AV_NOPTS_VALUE)
1777 if(input_files_ts_offset[ist->file_index])
1778 ist->next_pts= AV_NOPTS_VALUE;
1782 /* compute buffer size max (should use a complete heuristic) */
1783 for(i=0;i<nb_input_files;i++) {
1784 file_table[i].buffer_size_max = 2048;
1787 /* set meta data information from input file if required */
1788 for (i=0;i<nb_meta_data_maps;i++) {
1789 AVFormatContext *out_file;
1790 AVFormatContext *in_file;
1792 int out_file_index = meta_data_maps[i].out_file;
1793 int in_file_index = meta_data_maps[i].in_file;
1794 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1795 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1799 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1800 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1805 out_file = output_files[out_file_index];
1806 in_file = input_files[in_file_index];
1808 strcpy(out_file->title, in_file->title);
1809 strcpy(out_file->author, in_file->author);
1810 strcpy(out_file->copyright, in_file->copyright);
1811 strcpy(out_file->comment, in_file->comment);
1812 strcpy(out_file->album, in_file->album);
1813 out_file->year = in_file->year;
1814 out_file->track = in_file->track;
1815 strcpy(out_file->genre, in_file->genre);
1818 /* open files and write file headers */
1819 for(i=0;i<nb_output_files;i++) {
1820 os = output_files[i];
1821 if (av_write_header(os) < 0) {
1822 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);
1837 for(; received_sigterm == 0;) {
1838 int file_index, ist_index;
1846 /* if 'q' pressed, exits */
1850 /* read_key() returns 0 on EOF */
1856 /* select the stream that we must read now by looking at the
1857 smallest output pts */
1859 for(i=0;i<nb_ostreams;i++) {
1862 os = output_files[ost->file_index];
1863 ist = ist_table[ost->source_index];
1864 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1865 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1867 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1868 ipts = (double)ist->pts;
1869 if (!file_table[ist->file_index].eof_reached){
1870 if(ipts < ipts_min) {
1872 if(input_sync ) file_index = ist->file_index;
1874 if(opts < opts_min) {
1876 if(!input_sync) file_index = ist->file_index;
1879 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1884 /* if none, if is finished */
1885 if (file_index < 0) {
1889 /* finish if recording time exhausted */
1890 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1893 /* finish if limit size exhausted */
1894 if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1897 /* read a frame from it and output it in the fifo */
1898 is = input_files[file_index];
1899 if (av_read_frame(is, &pkt) < 0) {
1900 file_table[file_index].eof_reached = 1;
1901 if (opt_shortest) break; else continue; //
1905 stream_no_data = is;
1910 av_pkt_dump(stdout, &pkt, do_hex_dump);
1912 /* the following test is needed in case new streams appear
1913 dynamically in stream : we ignore them */
1914 if (pkt.stream_index >= file_table[file_index].nb_streams)
1915 goto discard_packet;
1916 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1917 ist = ist_table[ist_index];
1919 goto discard_packet;
1921 // fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
1922 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1923 int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1924 if(FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1925 input_files_ts_offset[ist->file_index]-= delta;
1927 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1928 for(i=0; i<file_table[file_index].nb_streams; i++){
1929 int index= file_table[file_index].ist_index + i;
1930 ist_table[index]->next_pts += delta;
1931 ist_table[index]->is_start=1;
1936 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1937 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1940 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1941 ist->file_index, ist->index);
1943 av_free_packet(&pkt);
1948 av_free_packet(&pkt);
1950 /* dump report by using the output first video and audio streams */
1951 print_report(output_files, ost_table, nb_ostreams, 0);
1954 /* at the end of stream, we must flush the decoder buffers */
1955 for(i=0;i<nb_istreams;i++) {
1957 if (ist->decoding_needed) {
1958 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1964 /* write the trailer if needed and close file */
1965 for(i=0;i<nb_output_files;i++) {
1966 os = output_files[i];
1967 av_write_trailer(os);
1970 /* dump report by using the first video and audio streams */
1971 print_report(output_files, ost_table, nb_ostreams, 1);
1973 /* close each encoder */
1974 for(i=0;i<nb_ostreams;i++) {
1976 if (ost->encoding_needed) {
1977 av_freep(&ost->st->codec->stats_in);
1978 avcodec_close(ost->st->codec);
1982 /* close each decoder */
1983 for(i=0;i<nb_istreams;i++) {
1985 if (ist->decoding_needed) {
1986 avcodec_close(ist->st->codec);
1994 av_freep(&bit_buffer);
1995 av_free(file_table);
1998 for(i=0;i<nb_istreams;i++) {
2005 for(i=0;i<nb_ostreams;i++) {
2009 fclose(ost->logfile);
2010 ost->logfile = NULL;
2012 av_fifo_free(&ost->fifo); /* works even if fifo is not
2013 initialized but set to zero */
2014 av_free(ost->pict_tmp.data[0]);
2015 if (ost->video_resample)
2016 sws_freeContext(ost->img_resample_ctx);
2017 if (ost->audio_resample)
2018 audio_resample_close(ost->resample);
2031 int file_read(const char *filename)
2034 unsigned char buffer[1024];
2037 if (url_open(&h, filename, O_RDONLY) < 0) {
2038 printf("could not open '%s'\n", filename);
2042 len = url_read(h, buffer, sizeof(buffer));
2045 for(i=0;i<len;i++) putchar(buffer[i]);
2052 static void opt_format(const char *arg)
2054 /* compatibility stuff for pgmyuv */
2055 if (!strcmp(arg, "pgmyuv")) {
2056 pgmyuv_compatibility_hack=1;
2057 // opt_image_format(arg);
2061 file_iformat = av_find_input_format(arg);
2062 file_oformat = guess_format(arg, NULL, NULL);
2063 if (!file_iformat && !file_oformat) {
2064 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2069 static void opt_video_rc_eq(char *arg)
2074 static void opt_video_rc_override_string(char *arg)
2076 video_rc_override_string = arg;
2079 static void opt_me_threshold(const char *arg)
2081 me_threshold = atoi(arg);
2084 static void opt_verbose(const char *arg)
2086 verbose = atoi(arg);
2087 av_log_set_level(atoi(arg));
2090 static void opt_frame_rate(const char *arg)
2092 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2093 fprintf(stderr, "Incorrect frame rate\n");
2098 static void opt_frame_crop_top(const char *arg)
2100 frame_topBand = atoi(arg);
2101 if (frame_topBand < 0) {
2102 fprintf(stderr, "Incorrect top crop size\n");
2105 if ((frame_topBand % 2) != 0) {
2106 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2109 if ((frame_topBand) >= frame_height){
2110 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2113 frame_height -= frame_topBand;
2116 static void opt_frame_crop_bottom(const char *arg)
2118 frame_bottomBand = atoi(arg);
2119 if (frame_bottomBand < 0) {
2120 fprintf(stderr, "Incorrect bottom crop size\n");
2123 if ((frame_bottomBand % 2) != 0) {
2124 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2127 if ((frame_bottomBand) >= frame_height){
2128 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2131 frame_height -= frame_bottomBand;
2134 static void opt_frame_crop_left(const char *arg)
2136 frame_leftBand = atoi(arg);
2137 if (frame_leftBand < 0) {
2138 fprintf(stderr, "Incorrect left crop size\n");
2141 if ((frame_leftBand % 2) != 0) {
2142 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2145 if ((frame_leftBand) >= frame_width){
2146 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2149 frame_width -= frame_leftBand;
2152 static void opt_frame_crop_right(const char *arg)
2154 frame_rightBand = atoi(arg);
2155 if (frame_rightBand < 0) {
2156 fprintf(stderr, "Incorrect right crop size\n");
2159 if ((frame_rightBand % 2) != 0) {
2160 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2163 if ((frame_rightBand) >= frame_width){
2164 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2167 frame_width -= frame_rightBand;
2170 static void opt_frame_size(const char *arg)
2172 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2173 fprintf(stderr, "Incorrect frame size\n");
2176 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2177 fprintf(stderr, "Frame size must be a multiple of 2\n");
2183 #define SCALEBITS 10
2184 #define ONE_HALF (1 << (SCALEBITS - 1))
2185 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2187 #define RGB_TO_Y(r, g, b) \
2188 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2189 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2191 #define RGB_TO_U(r1, g1, b1, shift)\
2192 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2193 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2195 #define RGB_TO_V(r1, g1, b1, shift)\
2196 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2197 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2199 static void opt_pad_color(const char *arg) {
2200 /* Input is expected to be six hex digits similar to
2201 how colors are expressed in html tags (but without the #) */
2202 int rgb = strtol(arg, NULL, 16);
2206 g = ((rgb >> 8) & 255);
2209 padcolor[0] = RGB_TO_Y(r,g,b);
2210 padcolor[1] = RGB_TO_U(r,g,b,0);
2211 padcolor[2] = RGB_TO_V(r,g,b,0);
2214 static void opt_frame_pad_top(const char *arg)
2216 frame_padtop = atoi(arg);
2217 if (frame_padtop < 0) {
2218 fprintf(stderr, "Incorrect top pad size\n");
2221 if ((frame_padtop % 2) != 0) {
2222 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2227 static void opt_frame_pad_bottom(const char *arg)
2229 frame_padbottom = atoi(arg);
2230 if (frame_padbottom < 0) {
2231 fprintf(stderr, "Incorrect bottom pad size\n");
2234 if ((frame_padbottom % 2) != 0) {
2235 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2241 static void opt_frame_pad_left(const char *arg)
2243 frame_padleft = atoi(arg);
2244 if (frame_padleft < 0) {
2245 fprintf(stderr, "Incorrect left pad size\n");
2248 if ((frame_padleft % 2) != 0) {
2249 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2255 static void opt_frame_pad_right(const char *arg)
2257 frame_padright = atoi(arg);
2258 if (frame_padright < 0) {
2259 fprintf(stderr, "Incorrect right pad size\n");
2262 if ((frame_padright % 2) != 0) {
2263 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2269 static void opt_frame_pix_fmt(const char *arg)
2271 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2274 static void opt_frame_aspect_ratio(const char *arg)
2280 p = strchr(arg, ':');
2282 x = strtol(arg, (char **)&arg, 10);
2284 y = strtol(arg+1, (char **)&arg, 10);
2286 ar = (double)x / (double)y;
2288 ar = strtod(arg, (char **)&arg);
2291 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2294 frame_aspect_ratio = ar;
2297 static void opt_qscale(const char *arg)
2299 video_qscale = atof(arg);
2300 if (video_qscale <= 0 ||
2301 video_qscale > 255) {
2302 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2307 static void opt_qdiff(const char *arg)
2309 video_qdiff = atoi(arg);
2310 if (video_qdiff < 0 ||
2312 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2317 static void opt_packet_size(const char *arg)
2319 packet_size= atoi(arg);
2322 static void opt_strict(const char *arg)
2327 static void opt_top_field_first(const char *arg)
2329 top_field_first= atoi(arg);
2332 static void opt_thread_count(const char *arg)
2334 thread_count= atoi(arg);
2335 #if !defined(HAVE_THREADS)
2337 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2341 static void opt_audio_bitrate(const char *arg)
2343 audio_bit_rate = atoi(arg) * 1000;
2346 static void opt_audio_rate(const char *arg)
2348 audio_sample_rate = atoi(arg);
2351 static void opt_audio_channels(const char *arg)
2353 audio_channels = atoi(arg);
2356 static void opt_video_device(const char *arg)
2358 video_device = av_strdup(arg);
2361 static void opt_grab_device(const char *arg)
2363 grab_device = av_strdup(arg);
2366 static void opt_video_channel(const char *arg)
2368 video_channel = strtol(arg, NULL, 0);
2371 static void opt_video_standard(const char *arg)
2373 video_standard = av_strdup(arg);
2376 static void opt_audio_device(const char *arg)
2378 audio_device = av_strdup(arg);
2381 static void opt_codec(int *pstream_copy, int *pcodec_id,
2382 int codec_type, const char *arg)
2386 if (!strcmp(arg, "copy")) {
2391 if (!strcmp(p->name, arg) && p->type == codec_type)
2396 fprintf(stderr, "Unknown codec '%s'\n", arg);
2404 static void opt_audio_codec(const char *arg)
2406 opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2409 static void opt_audio_tag(const char *arg)
2412 audio_codec_tag= strtol(arg, &tail, 0);
2415 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2418 static void opt_video_tag(const char *arg)
2421 video_codec_tag= strtol(arg, &tail, 0);
2424 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2427 static void add_frame_hooker(const char *arg)
2432 char *args = av_strdup(arg);
2436 argv[0] = strtok(args, " ");
2437 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2440 i = frame_hook_add(argc, argv);
2443 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2448 const char *motion_str[] = {
2461 static void opt_motion_estimation(const char *arg)
2467 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2470 if (!strcmp(*p, arg))
2474 me_method = (p - motion_str) + 1;
2477 static void opt_video_codec(const char *arg)
2479 opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2482 static void opt_subtitle_codec(const char *arg)
2484 opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2487 static void opt_map(const char *arg)
2493 m = &stream_maps[nb_stream_maps++];
2495 m->file_index = strtol(arg, (char **)&p, 0);
2499 m->stream_index = strtol(p, (char **)&p, 0);
2502 m->sync_file_index = strtol(p, (char **)&p, 0);
2505 m->sync_stream_index = strtol(p, (char **)&p, 0);
2507 m->sync_file_index = m->file_index;
2508 m->sync_stream_index = m->stream_index;
2512 static void opt_map_meta_data(const char *arg)
2518 m = &meta_data_maps[nb_meta_data_maps++];
2520 m->out_file = strtol(arg, (char **)&p, 0);
2524 m->in_file = strtol(p, (char **)&p, 0);
2527 static void opt_recording_time(const char *arg)
2529 recording_time = parse_date(arg, 1);
2532 static void opt_start_time(const char *arg)
2534 start_time = parse_date(arg, 1);
2537 static void opt_rec_timestamp(const char *arg)
2539 rec_timestamp = parse_date(arg, 0) / 1000000;
2542 static void opt_input_ts_offset(const char *arg)
2544 input_ts_offset = parse_date(arg, 1);
2547 static void opt_input_file(const char *filename)
2549 AVFormatContext *ic;
2550 AVFormatParameters params, *ap = ¶ms;
2551 int err, i, ret, rfps, rfps_base;
2554 if (!strcmp(filename, "-"))
2557 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2558 !strcmp( filename, "/dev/stdin" );
2560 /* get default parameters from command line */
2561 ic = av_alloc_format_context();
2563 memset(ap, 0, sizeof(*ap));
2564 ap->prealloced_context = 1;
2565 ap->sample_rate = audio_sample_rate;
2566 ap->channels = audio_channels;
2567 ap->time_base.den = frame_rate;
2568 ap->time_base.num = frame_rate_base;
2569 ap->width = frame_width + frame_padleft + frame_padright;
2570 ap->height = frame_height + frame_padtop + frame_padbottom;
2571 ap->pix_fmt = frame_pix_fmt;
2572 ap->device = grab_device;
2573 ap->channel = video_channel;
2574 ap->standard = video_standard;
2575 ap->video_codec_id = video_codec_id;
2576 ap->audio_codec_id = audio_codec_id;
2577 if(pgmyuv_compatibility_hack)
2578 ap->video_codec_id= CODEC_ID_PGMYUV;
2580 for(i=0; i<opt_name_count; i++){
2581 const AVOption *opt;
2582 double d= av_get_double(avformat_opts, opt_names[i], &opt);
2583 if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2584 av_set_double(ic, opt_names[i], d);
2586 /* open the input file with generic libav function */
2587 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2589 print_error(filename, err);
2593 ic->loop_input = loop_input;
2595 /* If not enough info to get the stream parameters, we decode the
2596 first frames to get it. (used in mpeg case for example) */
2597 ret = av_find_stream_info(ic);
2598 if (ret < 0 && verbose >= 0) {
2599 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2603 timestamp = start_time;
2604 /* add the stream start time */
2605 if (ic->start_time != AV_NOPTS_VALUE)
2606 timestamp += ic->start_time;
2608 /* if seeking requested, we execute it */
2609 if (start_time != 0) {
2610 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2612 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2613 filename, (double)timestamp / AV_TIME_BASE);
2615 /* reset seek info */
2619 /* update the current parameters so that they match the one of the input stream */
2620 for(i=0;i<ic->nb_streams;i++) {
2622 AVCodecContext *enc = ic->streams[i]->codec;
2623 #if defined(HAVE_THREADS)
2625 avcodec_thread_init(enc, thread_count);
2627 enc->thread_count= thread_count;
2628 switch(enc->codec_type) {
2629 case CODEC_TYPE_AUDIO:
2630 for(j=0; j<opt_name_count; j++){
2631 const AVOption *opt;
2632 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2633 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2634 av_set_double(enc, opt_names[j], d);
2636 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2637 audio_channels = enc->channels;
2638 audio_sample_rate = enc->sample_rate;
2640 ic->streams[i]->discard= AVDISCARD_ALL;
2642 case CODEC_TYPE_VIDEO:
2643 for(j=0; j<opt_name_count; j++){
2644 const AVOption *opt;
2645 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2646 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2647 av_set_double(enc, opt_names[j], d);
2649 frame_height = enc->height;
2650 frame_width = enc->width;
2651 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2652 frame_pix_fmt = enc->pix_fmt;
2653 rfps = ic->streams[i]->r_frame_rate.num;
2654 rfps_base = ic->streams[i]->r_frame_rate.den;
2655 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2657 enc->debug |= FF_DEBUG_MV;
2659 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2662 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2663 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2665 (float)rfps / rfps_base, rfps, rfps_base);
2667 /* update the current frame rate to match the stream frame rate */
2669 frame_rate_base = rfps_base;
2671 enc->rate_emu = rate_emu;
2673 ic->streams[i]->discard= AVDISCARD_ALL;
2674 else if(video_discard)
2675 ic->streams[i]->discard= video_discard;
2677 case CODEC_TYPE_DATA:
2679 case CODEC_TYPE_SUBTITLE:
2681 case CODEC_TYPE_UNKNOWN:
2688 input_files[nb_input_files] = ic;
2689 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2690 /* dump the file content */
2692 dump_format(ic, nb_input_files, filename, 0);
2695 file_iformat = NULL;
2696 file_oformat = NULL;
2704 static void opt_grab(const char *arg)
2706 file_iformat = av_find_input_format(arg);
2710 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2712 int has_video, has_audio, i, j;
2713 AVFormatContext *ic;
2717 for(j=0;j<nb_input_files;j++) {
2718 ic = input_files[j];
2719 for(i=0;i<ic->nb_streams;i++) {
2720 AVCodecContext *enc = ic->streams[i]->codec;
2721 switch(enc->codec_type) {
2722 case CODEC_TYPE_AUDIO:
2725 case CODEC_TYPE_VIDEO:
2728 case CODEC_TYPE_DATA:
2729 case CODEC_TYPE_UNKNOWN:
2730 case CODEC_TYPE_SUBTITLE:
2737 *has_video_ptr = has_video;
2738 *has_audio_ptr = has_audio;
2741 static void new_video_stream(AVFormatContext *oc)
2744 AVCodecContext *video_enc;
2747 st = av_new_stream(oc, oc->nb_streams);
2749 fprintf(stderr, "Could not alloc stream\n");
2752 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2753 video_bitstream_filters= NULL;
2755 #if defined(HAVE_THREADS)
2757 avcodec_thread_init(st->codec, thread_count);
2760 video_enc = st->codec;
2763 video_enc->codec_tag= video_codec_tag;
2765 if( (video_global_header&1)
2766 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2767 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2768 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2770 if(video_global_header&2){
2771 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2772 avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2775 if (video_stream_copy) {
2776 st->stream_copy = 1;
2777 video_enc->codec_type = CODEC_TYPE_VIDEO;
2783 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2784 if (video_codec_id != CODEC_ID_NONE)
2785 codec_id = video_codec_id;
2787 video_enc->codec_id = codec_id;
2788 codec = avcodec_find_encoder(codec_id);
2790 for(i=0; i<opt_name_count; i++){
2791 const AVOption *opt;
2792 double d= av_get_double(avctx_opts, opt_names[i], &opt);
2793 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2794 av_set_double(video_enc, opt_names[i], d);
2797 video_enc->time_base.den = frame_rate;
2798 video_enc->time_base.num = frame_rate_base;
2799 if(codec && codec->supported_framerates){
2800 const AVRational *p= codec->supported_framerates;
2801 AVRational req= (AVRational){frame_rate, frame_rate_base};
2802 const AVRational *best=NULL;
2803 AVRational best_error= (AVRational){INT_MAX, 1};
2804 for(; p->den!=0; p++){
2805 AVRational error= av_sub_q(req, *p);
2806 if(error.num <0) error.num *= -1;
2807 if(av_cmp_q(error, best_error) < 0){
2812 video_enc->time_base.den= best->num;
2813 video_enc->time_base.num= best->den;
2816 video_enc->width = frame_width + frame_padright + frame_padleft;
2817 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2818 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2819 video_enc->pix_fmt = frame_pix_fmt;
2821 if(codec && codec->pix_fmts){
2822 const enum PixelFormat *p= codec->pix_fmts;
2824 if(*p == video_enc->pix_fmt)
2828 video_enc->pix_fmt = codec->pix_fmts[0];
2832 video_enc->gop_size = 0;
2833 if (video_qscale || same_quality) {
2834 video_enc->flags |= CODEC_FLAG_QSCALE;
2835 video_enc->global_quality=
2836 st->quality = FF_QP2LAMBDA * video_qscale;
2840 video_enc->intra_matrix = intra_matrix;
2842 video_enc->inter_matrix = inter_matrix;
2844 video_enc->max_qdiff = video_qdiff;
2845 video_enc->rc_eq = video_rc_eq;
2846 video_enc->thread_count = thread_count;
2847 p= video_rc_override_string;
2850 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2852 fprintf(stderr, "error parsing rc_override\n");
2855 video_enc->rc_override=
2856 av_realloc(video_enc->rc_override,
2857 sizeof(RcOverride)*(i+1));
2858 video_enc->rc_override[i].start_frame= start;
2859 video_enc->rc_override[i].end_frame = end;
2861 video_enc->rc_override[i].qscale= q;
2862 video_enc->rc_override[i].quality_factor= 1.0;
2865 video_enc->rc_override[i].qscale= 0;
2866 video_enc->rc_override[i].quality_factor= -q/100.0;
2871 video_enc->rc_override_count=i;
2872 if (!video_enc->rc_initial_buffer_occupancy)
2873 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2874 video_enc->me_threshold= me_threshold;
2875 video_enc->intra_dc_precision= intra_dc_precision - 8;
2876 video_enc->strict_std_compliance = strict;
2879 video_enc->rtp_mode= 1;
2880 video_enc->rtp_payload_size= packet_size;
2884 video_enc->flags|= CODEC_FLAG_PSNR;
2886 video_enc->me_method = me_method;
2891 video_enc->flags |= CODEC_FLAG_PASS1;
2893 video_enc->flags |= CODEC_FLAG_PASS2;
2898 /* reset some key parameters */
2900 video_codec_id = CODEC_ID_NONE;
2901 video_stream_copy = 0;
2904 static void new_audio_stream(AVFormatContext *oc)
2907 AVCodecContext *audio_enc;
2910 st = av_new_stream(oc, oc->nb_streams);
2912 fprintf(stderr, "Could not alloc stream\n");
2916 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2917 audio_bitstream_filters= NULL;
2919 #if defined(HAVE_THREADS)
2921 avcodec_thread_init(st->codec, thread_count);
2924 audio_enc = st->codec;
2925 audio_enc->codec_type = CODEC_TYPE_AUDIO;
2926 audio_enc->strict_std_compliance = strict;
2929 audio_enc->codec_tag= audio_codec_tag;
2931 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2932 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2933 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2935 if (audio_stream_copy) {
2936 st->stream_copy = 1;
2937 audio_enc->channels = audio_channels;
2939 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2941 for(i=0; i<opt_name_count; i++){
2942 const AVOption *opt;
2943 double d= av_get_double(avctx_opts, opt_names[i], &opt);
2944 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2945 av_set_double(audio_enc, opt_names[i], d);
2948 if (audio_codec_id != CODEC_ID_NONE)
2949 codec_id = audio_codec_id;
2950 audio_enc->codec_id = codec_id;
2952 audio_enc->bit_rate = audio_bit_rate;
2953 if (audio_qscale > QSCALE_NONE) {
2954 audio_enc->flags |= CODEC_FLAG_QSCALE;
2955 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
2957 audio_enc->thread_count = thread_count;
2958 audio_enc->channels = audio_channels;
2960 audio_enc->sample_rate = audio_sample_rate;
2961 audio_enc->time_base= (AVRational){1, audio_sample_rate};
2962 if (audio_language) {
2963 pstrcpy(st->language, sizeof(st->language), audio_language);
2964 av_free(audio_language);
2965 audio_language = NULL;
2968 /* reset some key parameters */
2970 audio_codec_id = CODEC_ID_NONE;
2971 audio_stream_copy = 0;
2974 static void opt_new_subtitle_stream(void)
2976 AVFormatContext *oc;
2978 AVCodecContext *subtitle_enc;
2981 if (nb_output_files <= 0) {
2982 fprintf(stderr, "At least one output file must be specified\n");
2985 oc = output_files[nb_output_files - 1];
2987 st = av_new_stream(oc, oc->nb_streams);
2989 fprintf(stderr, "Could not alloc stream\n");
2993 subtitle_enc = st->codec;
2994 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
2995 if (subtitle_stream_copy) {
2996 st->stream_copy = 1;
2998 for(i=0; i<opt_name_count; i++){
2999 const AVOption *opt;
3000 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3001 if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3002 av_set_double(subtitle_enc, opt_names[i], d);
3004 subtitle_enc->codec_id = subtitle_codec_id;
3007 if (subtitle_language) {
3008 pstrcpy(st->language, sizeof(st->language), subtitle_language);
3009 av_free(subtitle_language);
3010 subtitle_language = NULL;
3013 subtitle_codec_id = CODEC_ID_NONE;
3014 subtitle_stream_copy = 0;
3017 static void opt_new_audio_stream(void)
3019 AVFormatContext *oc;
3020 if (nb_output_files <= 0) {
3021 fprintf(stderr, "At least one output file must be specified\n");
3024 oc = output_files[nb_output_files - 1];
3025 new_audio_stream(oc);
3028 static void opt_new_video_stream(void)
3030 AVFormatContext *oc;
3031 if (nb_output_files <= 0) {
3032 fprintf(stderr, "At least one output file must be specified\n");
3035 oc = output_files[nb_output_files - 1];
3036 new_video_stream(oc);
3039 static void opt_output_file(const char *filename)
3041 AVFormatContext *oc;
3042 int use_video, use_audio, input_has_video, input_has_audio, i;
3043 AVFormatParameters params, *ap = ¶ms;
3045 if (!strcmp(filename, "-"))
3048 oc = av_alloc_format_context();
3050 if (!file_oformat) {
3051 file_oformat = guess_format(NULL, filename, NULL);
3052 if (!file_oformat) {
3053 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3059 oc->oformat = file_oformat;
3060 pstrcpy(oc->filename, sizeof(oc->filename), filename);
3062 if (!strcmp(file_oformat->name, "ffm") &&
3063 strstart(filename, "http:", NULL)) {
3064 /* special case for files sent to ffserver: we get the stream
3065 parameters from ffserver */
3066 if (read_ffserver_streams(oc, filename) < 0) {
3067 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3071 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3072 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3074 /* disable if no corresponding type found and at least one
3076 if (nb_input_files > 0) {
3077 check_audio_video_inputs(&input_has_video, &input_has_audio);
3078 if (!input_has_video)
3080 if (!input_has_audio)
3084 /* manual disable */
3085 if (audio_disable) {
3088 if (video_disable) {
3093 new_video_stream(oc);
3097 new_audio_stream(oc);
3100 oc->timestamp = rec_timestamp;
3103 pstrcpy(oc->title, sizeof(oc->title), str_title);
3105 pstrcpy(oc->author, sizeof(oc->author), str_author);
3107 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3109 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3111 pstrcpy(oc->album, sizeof(oc->album), str_album);
3114 output_files[nb_output_files++] = oc;
3116 /* check filename in case of an image number is expected */
3117 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3118 if (!av_filename_number_test(oc->filename)) {
3119 print_error(oc->filename, AVERROR_NUMEXPECTED);
3124 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3125 /* test if it already exists to avoid loosing precious files */
3126 if (!file_overwrite &&
3127 (strchr(filename, ':') == NULL ||
3128 strstart(filename, "file:", NULL))) {
3129 if (url_exist(filename)) {
3132 if ( !using_stdin ) {
3133 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3136 if (toupper(c) != 'Y') {
3137 fprintf(stderr, "Not overwriting - exiting\n");
3142 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3149 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3150 fprintf(stderr, "Could not open '%s'\n", filename);
3155 memset(ap, 0, sizeof(*ap));
3156 if (av_set_parameters(oc, ap) < 0) {
3157 fprintf(stderr, "%s: Invalid encoding parameters\n",
3162 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3163 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3164 oc->loop_output = loop_output;
3166 for(i=0; i<opt_name_count; i++){
3167 const AVOption *opt;
3168 double d = av_get_double(avformat_opts, opt_names[i], &opt);
3169 if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3170 av_set_double(oc, opt_names[i], d);
3173 /* reset some options */
3174 file_oformat = NULL;
3175 file_iformat = NULL;
3178 /* prepare dummy protocols for grab */
3179 static void prepare_grab(void)
3181 int has_video, has_audio, i, j;
3182 AVFormatContext *oc;
3183 AVFormatContext *ic;
3184 AVFormatParameters vp1, *vp = &vp1;
3185 AVFormatParameters ap1, *ap = &ap1;
3187 /* see if audio/video inputs are needed */
3190 memset(ap, 0, sizeof(*ap));
3191 memset(vp, 0, sizeof(*vp));
3192 vp->time_base.num= 1;
3193 for(j=0;j<nb_output_files;j++) {
3194 oc = output_files[j];
3195 for(i=0;i<oc->nb_streams;i++) {
3196 AVCodecContext *enc = oc->streams[i]->codec;
3197 switch(enc->codec_type) {
3198 case CODEC_TYPE_AUDIO:
3199 if (enc->sample_rate > ap->sample_rate)
3200 ap->sample_rate = enc->sample_rate;
3201 if (enc->channels > ap->channels)
3202 ap->channels = enc->channels;
3205 case CODEC_TYPE_VIDEO:
3206 if (enc->width > vp->width)
3207 vp->width = enc->width;
3208 if (enc->height > vp->height)
3209 vp->height = enc->height;
3211 if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3212 vp->time_base = enc->time_base;
3213 vp->width += frame_leftBand + frame_rightBand;
3214 vp->width -= (frame_padleft + frame_padright);
3215 vp->height += frame_topBand + frame_bottomBand;
3216 vp->height -= (frame_padtop + frame_padbottom);
3226 if (has_video == 0 && has_audio == 0) {
3227 fprintf(stderr, "Output file must have at least one audio or video stream\n");
3232 AVInputFormat *fmt1;
3233 #warning FIXME: find a better interface
3234 if(video_device&&!strncmp(video_device,"x11:",4)) {
3235 video_grab_format="x11grab";
3237 fmt1 = av_find_input_format(video_grab_format);
3238 vp->device = video_device;
3239 vp->channel = video_channel;
3240 vp->standard = video_standard;
3241 vp->pix_fmt = frame_pix_fmt;
3242 if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3243 fprintf(stderr, "Could not find video grab device\n");
3246 /* If not enough info to get the stream parameters, we decode the
3247 first frames to get it. */
3248 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3249 fprintf(stderr, "Could not find video grab parameters\n");
3252 /* by now video grab has one stream */
3253 ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3254 ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3255 input_files[nb_input_files] = ic;
3258 dump_format(ic, nb_input_files, "", 0);
3262 if (has_audio && audio_grab_format) {
3263 AVInputFormat *fmt1;
3264 fmt1 = av_find_input_format(audio_grab_format);
3265 ap->device = audio_device;
3266 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3267 fprintf(stderr, "Could not find audio grab device\n");
3270 input_files[nb_input_files] = ic;
3273 dump_format(ic, nb_input_files, "", 0);
3279 /* same option as mencoder */
3280 static void opt_pass(const char *pass_str)
3283 pass = atoi(pass_str);
3284 if (pass != 1 && pass != 2) {
3285 fprintf(stderr, "pass number can be only 1 or 2\n");
3291 #if defined(__MINGW32__) || defined(CONFIG_OS2)
3292 static int64_t getutime(void)
3294 return av_gettime();
3297 static int64_t getutime(void)
3299 struct rusage rusage;
3301 getrusage(RUSAGE_SELF, &rusage);
3302 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3306 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3307 extern int ffm_nopts;
3310 static void show_formats(void)
3312 AVInputFormat *ifmt;
3313 AVOutputFormat *ofmt;
3316 const char **pp, *last_name;
3318 printf("File formats:\n");
3323 const char *name=NULL;
3324 const char *long_name=NULL;
3326 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3327 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3328 strcmp(ofmt->name, last_name)>0){
3330 long_name= ofmt->long_name;
3334 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3335 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3336 strcmp(ifmt->name, last_name)>0){
3338 long_name= ifmt->long_name;
3341 if(name && strcmp(ifmt->name, name)==0)
3353 long_name ? long_name:" ");
3357 printf("Codecs:\n");
3363 const char *type_str;
3366 for(p = first_avcodec; p != NULL; p = p->next) {
3367 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3368 strcmp(p->name, last_name)>0){
3370 decode= encode= cap=0;
3372 if(p2 && strcmp(p->name, p2->name)==0){
3373 if(p->decode) decode=1;
3374 if(p->encode) encode=1;
3375 cap |= p->capabilities;
3380 last_name= p2->name;
3383 case CODEC_TYPE_VIDEO:
3386 case CODEC_TYPE_AUDIO:
3389 case CODEC_TYPE_SUBTITLE:
3398 decode ? "D": (/*p2->decoder ? "d":*/" "),
3401 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3402 cap & CODEC_CAP_DR1 ? "D":" ",
3403 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3405 /* if(p2->decoder && decode==0)
3406 printf(" use %s for decoding", p2->decoder->name);*/
3411 printf("Supported file protocols:\n");
3412 for(up = first_protocol; up != NULL; up = up->next)
3413 printf(" %s:", up->name);
3416 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3417 printf("Motion estimation methods:\n");
3421 if ((pp - motion_str + 1) == ME_ZERO)
3422 printf("(fastest)");
3423 else if ((pp - motion_str + 1) == ME_FULL)
3424 printf("(slowest)");
3425 else if ((pp - motion_str + 1) == ME_EPZS)
3426 printf("(default)");
3431 "Note, the names of encoders and decoders dont always match, so there are\n"
3432 "several cases where the above table shows encoder only or decoder only entries\n"
3433 "even though both encoding and decoding are supported for example, the h263\n"
3434 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3439 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3442 const char *p = str;
3449 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3456 static void opt_inter_matrix(const char *arg)
3458 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3459 parse_matrix_coeffs(inter_matrix, arg);
3462 static void opt_intra_matrix(const char *arg)
3464 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3465 parse_matrix_coeffs(intra_matrix, arg);
3468 static void opt_target(const char *arg)
3471 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3473 if(!strncmp(arg, "pal-", 4)) {
3476 } else if(!strncmp(arg, "ntsc-", 5)) {
3479 } else if(!strncmp(arg, "film-", 5)) {
3484 /* Calculate FR via float to avoid int overflow */
3485 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3488 } else if((fr == 29970) || (fr == 23976)) {
3491 /* Try to determine PAL/NTSC by peeking in the input files */
3492 if(nb_input_files) {
3494 for(j = 0; j < nb_input_files; j++) {
3495 for(i = 0; i < input_files[j]->nb_streams; i++) {
3496 AVCodecContext *c = input_files[j]->streams[i]->codec;
3497 if(c->codec_type != CODEC_TYPE_VIDEO)
3499 fr = c->time_base.den * 1000 / c->time_base.num;
3503 } else if((fr == 29970) || (fr == 23976)) {
3513 if(verbose && norm >= 0)
3514 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3518 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3519 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3520 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3524 if(!strcmp(arg, "vcd")) {
3526 opt_video_codec("mpeg1video");
3527 opt_audio_codec("mp2");
3530 opt_frame_size(norm ? "352x240" : "352x288");
3531 opt_frame_rate(frame_rates[norm]);
3532 opt_default("gop", norm ? "18" : "15");
3534 opt_default("b", "1150000");
3535 opt_default("maxrate", "1150000");
3536 opt_default("minrate", "1150000");
3537 opt_default("bufsize", "327680"); // 40*1024*8;
3539 audio_bit_rate = 224000;
3540 audio_sample_rate = 44100;
3542 opt_default("packetsize", "2324");
3543 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3545 /* We have to offset the PTS, so that it is consistent with the SCR.
3546 SCR starts at 36000, but the first two packs contain only padding
3547 and the first pack from the other stream, respectively, may also have
3548 been written before.
3549 So the real data starts at SCR 36000+3*1200. */
3550 mux_preload= (36000+3*1200) / 90000.0; //0.44
3551 } else if(!strcmp(arg, "svcd")) {
3553 opt_video_codec("mpeg2video");
3554 opt_audio_codec("mp2");
3557 opt_frame_size(norm ? "480x480" : "480x576");
3558 opt_frame_rate(frame_rates[norm]);
3559 opt_default("gop", norm ? "18" : "15");
3561 opt_default("b", "2040000");
3562 opt_default("maxrate", "2516000");
3563 opt_default("minrate", "0"); //1145000;
3564 opt_default("bufsize", "1835008"); //224*1024*8;
3565 opt_default("flags", "+SCAN_OFFSET");
3568 audio_bit_rate = 224000;
3569 audio_sample_rate = 44100;
3571 opt_default("packetsize", "2324");
3573 } else if(!strcmp(arg, "dvd")) {
3575 opt_video_codec("mpeg2video");
3576 opt_audio_codec("ac3");
3579 opt_frame_size(norm ? "720x480" : "720x576");
3580 opt_frame_rate(frame_rates[norm]);
3581 opt_default("gop", norm ? "18" : "15");
3583 opt_default("b", "6000000");
3584 opt_default("maxrate", "9000000");
3585 opt_default("minrate", "0"); //1500000;
3586 opt_default("bufsize", "1835008"); //224*1024*8;
3588 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3589 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3591 audio_bit_rate = 448000;
3592 audio_sample_rate = 48000;
3594 } else if(!strncmp(arg, "dv", 2)) {
3598 opt_frame_size(norm ? "720x480" : "720x576");
3599 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3600 (norm ? "yuv411p" : "yuv420p"));
3601 opt_frame_rate(frame_rates[norm]);
3603 audio_sample_rate = 48000;
3607 fprintf(stderr, "Unknown target: %s\n", arg);
3612 static void opt_video_bsf(const char *arg)
3614 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3615 AVBitStreamFilterContext **bsfp;
3618 fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3622 bsfp= &video_bitstream_filters;
3624 bsfp= &(*bsfp)->next;
3629 //FIXME avoid audio - video code duplication
3630 static void opt_audio_bsf(const char *arg)
3632 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3633 AVBitStreamFilterContext **bsfp;
3636 fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3640 bsfp= &audio_bitstream_filters;
3642 bsfp= &(*bsfp)->next;
3647 static void show_version(void)
3649 /* TODO: add function interface to avutil and avformat */
3650 fprintf(stderr, "ffmpeg " FFMPEG_VERSION "\n"
3654 LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3658 static int opt_default(const char *opt, const char *arg){
3659 const AVOption *o= av_set_string(avctx_opts, opt, arg);
3661 o = av_set_string(avformat_opts, opt, arg);
3665 // 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));
3667 //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3668 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3669 opt_names[opt_name_count++]= o->name;
3671 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3672 /* disable generate of real time pts in ffm (need to be supressed anyway) */
3673 if(avctx_opts->flags & CODEC_FLAG_BITEXACT)
3677 if(avctx_opts->debug)
3678 av_log_set_level(AV_LOG_DEBUG);
3682 const OptionDef options[] = {
3684 { "L", 0, {(void*)show_license}, "show license" },
3685 { "h", 0, {(void*)show_help}, "show help" },
3686 { "version", 0, {(void*)show_version}, "show version" },
3687 { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3688 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3689 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3690 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3691 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3692 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3693 { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3694 { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
3695 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3696 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3697 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3698 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3699 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3700 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3701 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3702 { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3703 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3704 "add timings for benchmarking" },
3705 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3706 "dump each input packet" },
3707 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3708 "when dumping packets, also dump the payload" },
3709 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3710 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3711 { "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)", "" },
3712 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3713 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3714 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3715 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3716 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3717 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3718 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3719 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3720 { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3723 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3724 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3725 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3726 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3727 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3728 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3729 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3730 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3731 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3732 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3733 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3734 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3735 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3736 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3737 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3738 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3739 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3740 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3741 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3742 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3743 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
3744 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3745 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3746 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3747 { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3749 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
3750 { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
3751 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3752 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3753 "use same video quality as source (implies VBR)" },
3754 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3755 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3756 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3757 "deinterlace pictures" },
3758 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3759 { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
3760 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3761 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3762 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3763 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3764 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3765 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3766 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3767 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3770 { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
3771 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3772 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3773 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3774 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3775 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3776 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3777 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3778 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3779 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3781 /* subtitle options */
3782 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3783 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3784 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3787 { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
3788 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3789 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3790 { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
3792 /* G.2 grab options */
3793 { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
3794 { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
3797 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3798 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3800 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
3801 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
3803 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3807 static void show_banner(void)
3809 fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2006 Fabrice Bellard, et al.\n");
3810 fprintf(stderr, " configuration: " FFMPEG_CONFIGURATION "\n");
3811 fprintf(stderr, " libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
3812 fprintf(stderr, " libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
3813 fprintf(stderr, " libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
3814 fprintf(stderr, " built on " __DATE__ " " __TIME__);
3816 fprintf(stderr, ", gcc: " __VERSION__ "\n");
3818 fprintf(stderr, ", using a non-gcc compiler\n");
3822 static void show_license(void)
3827 "FFmpeg is free software; you can redistribute it and/or modify\n"
3828 "it under the terms of the GNU General Public License as published by\n"
3829 "the Free Software Foundation; either version 2 of the License, or\n"
3830 "(at your option) any later version.\n"
3832 "FFmpeg is distributed in the hope that it will be useful,\n"
3833 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3834 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
3835 "GNU General Public License for more details.\n"
3837 "You should have received a copy of the GNU General Public License\n"
3838 "along with FFmpeg; if not, write to the Free Software\n"
3839 "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
3843 "FFmpeg is free software; you can redistribute it and/or\n"
3844 "modify it under the terms of the GNU Lesser General Public\n"
3845 "License as published by the Free Software Foundation; either\n"
3846 "version 2.1 of the License, or (at your option) any later version.\n"
3848 "FFmpeg is distributed in the hope that it will be useful,\n"
3849 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3850 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
3851 "Lesser General Public License for more details.\n"
3853 "You should have received a copy of the GNU Lesser General Public\n"
3854 "License along with FFmpeg; if not, write to the Free Software\n"
3855 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
3861 static void show_help(void)
3864 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3865 "Hyper fast Audio and Video encoder\n");
3867 show_help_options(options, "Main options:\n",
3868 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3869 show_help_options(options, "\nVideo options:\n",
3870 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3872 show_help_options(options, "\nAdvanced Video options:\n",
3873 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3874 OPT_VIDEO | OPT_EXPERT);
3875 show_help_options(options, "\nAudio options:\n",
3876 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3878 show_help_options(options, "\nAdvanced Audio options:\n",
3879 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3880 OPT_AUDIO | OPT_EXPERT);
3881 show_help_options(options, "\nSubtitle options:\n",
3882 OPT_SUBTITLE | OPT_GRAB,
3884 show_help_options(options, "\nAudio/Video grab options:\n",
3887 show_help_options(options, "\nAdvanced options:\n",
3888 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3890 av_opt_show(avctx_opts, NULL);
3891 av_opt_show(avformat_opts, NULL);
3896 void parse_arg_file(const char *filename)
3898 opt_output_file(filename);
3901 int main(int argc, char **argv)
3908 avctx_opts= avcodec_alloc_context();
3909 avformat_opts = av_alloc_format_context();
3917 parse_options(argc, argv, options);
3919 /* file converter / grab */
3920 if (nb_output_files <= 0) {
3921 fprintf(stderr, "Must supply at least one output file\n");
3925 if (nb_input_files == 0) {
3931 av_encode(output_files, nb_output_files, input_files, nb_input_files,
3932 stream_maps, nb_stream_maps);
3933 ti = getutime() - ti;
3935 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3939 for(i=0;i<nb_output_files;i++) {
3940 /* maybe av_close_output_file ??? */
3941 AVFormatContext *s = output_files[i];
3943 if (!(s->oformat->flags & AVFMT_NOFILE))
3945 for(j=0;j<s->nb_streams;j++) {
3946 av_free(s->streams[j]->codec);
3947 av_free(s->streams[j]);
3951 for(i=0;i<nb_input_files;i++)
3952 av_close_input_file(input_files[i]);
3957 av_free(intra_matrix);
3959 av_free(inter_matrix);
3961 #ifdef POWERPC_PERFORMANCE_REPORT
3962 extern void powerpc_display_perf_report(void);
3963 powerpc_display_perf_report();
3964 #endif /* POWERPC_PERFORMANCE_REPORT */
3966 if (received_sigterm) {
3968 "Received signal %d: terminating.\n",
3969 (int) received_sigterm);
3973 exit(0); /* not all OS-es handle main() return value */