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:
1547 fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1550 codec->pix_fmt = icodec->pix_fmt;
1551 codec->width = icodec->width;
1552 codec->height = icodec->height;
1553 codec->has_b_frames = icodec->has_b_frames;
1555 case CODEC_TYPE_SUBTITLE:
1561 switch(codec->codec_type) {
1562 case CODEC_TYPE_AUDIO:
1563 if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1566 if (codec->channels == icodec->channels &&
1567 codec->sample_rate == icodec->sample_rate) {
1568 ost->audio_resample = 0;
1570 if (codec->channels != icodec->channels &&
1571 (icodec->codec_id == CODEC_ID_AC3 ||
1572 icodec->codec_id == CODEC_ID_DTS)) {
1573 /* Special case for 5:1 AC3 and DTS input */
1574 /* and mono or stereo output */
1575 /* Request specific number of channels */
1576 icodec->channels = codec->channels;
1577 if (codec->sample_rate == icodec->sample_rate)
1578 ost->audio_resample = 0;
1580 ost->audio_resample = 1;
1583 ost->audio_resample = 1;
1586 if(audio_sync_method>1)
1587 ost->audio_resample = 1;
1589 if(ost->audio_resample){
1590 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1591 codec->sample_rate, icodec->sample_rate);
1593 printf("Can't resample. Aborting.\n");
1597 ist->decoding_needed = 1;
1598 ost->encoding_needed = 1;
1600 case CODEC_TYPE_VIDEO:
1601 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1602 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1603 ost->video_resample = ((codec->width != icodec->width -
1604 (frame_leftBand + frame_rightBand) +
1605 (frame_padleft + frame_padright)) ||
1606 (codec->height != icodec->height -
1607 (frame_topBand + frame_bottomBand) +
1608 (frame_padtop + frame_padbottom)) ||
1609 (codec->pix_fmt != icodec->pix_fmt));
1610 if (ost->video_crop) {
1611 ost->topBand = frame_topBand;
1612 ost->leftBand = frame_leftBand;
1614 if (ost->video_pad) {
1615 ost->padtop = frame_padtop;
1616 ost->padleft = frame_padleft;
1617 ost->padbottom = frame_padbottom;
1618 ost->padright = frame_padright;
1619 if (!ost->video_resample) {
1620 avcodec_get_frame_defaults(&ost->pict_tmp);
1621 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1622 codec->width, codec->height ) )
1626 if (ost->video_resample) {
1627 avcodec_get_frame_defaults(&ost->pict_tmp);
1628 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1629 codec->width, codec->height ) )
1632 ost->img_resample_ctx = sws_getContext(
1633 icodec->width - (frame_leftBand + frame_rightBand),
1634 icodec->height - (frame_topBand + frame_bottomBand),
1636 codec->width - (frame_padleft + frame_padright),
1637 codec->height - (frame_padtop + frame_padbottom),
1639 sws_flags, NULL, NULL, NULL);
1640 if (ost->img_resample_ctx == NULL) {
1641 fprintf(stderr, "Cannot get resampling context\n");
1644 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1646 ost->encoding_needed = 1;
1647 ist->decoding_needed = 1;
1649 case CODEC_TYPE_SUBTITLE:
1650 ost->encoding_needed = 1;
1651 ist->decoding_needed = 1;
1658 if (ost->encoding_needed &&
1659 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1660 char logfilename[1024];
1665 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1667 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1668 if (codec->flags & CODEC_FLAG_PASS1) {
1669 f = fopen(logfilename, "w");
1671 perror(logfilename);
1676 /* read the log file */
1677 f = fopen(logfilename, "r");
1679 perror(logfilename);
1682 fseek(f, 0, SEEK_END);
1684 fseek(f, 0, SEEK_SET);
1685 logbuffer = av_malloc(size + 1);
1687 fprintf(stderr, "Could not allocate log buffer\n");
1690 size = fread(logbuffer, 1, size, f);
1692 logbuffer[size] = '\0';
1693 codec->stats_in = logbuffer;
1697 if(codec->codec_type == CODEC_TYPE_VIDEO){
1698 int size= codec->width * codec->height;
1699 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1704 bit_buffer = av_malloc(bit_buffer_size);
1708 /* dump the file output parameters - cannot be done before in case
1710 for(i=0;i<nb_output_files;i++) {
1711 dump_format(output_files[i], i, output_files[i]->filename, 1);
1714 /* dump the stream mapping */
1716 fprintf(stderr, "Stream mapping:\n");
1717 for(i=0;i<nb_ostreams;i++) {
1719 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1720 ist_table[ost->source_index]->file_index,
1721 ist_table[ost->source_index]->index,
1724 if (ost->sync_ist != ist_table[ost->source_index])
1725 fprintf(stderr, " [sync #%d.%d]",
1726 ost->sync_ist->file_index,
1727 ost->sync_ist->index);
1728 fprintf(stderr, "\n");
1732 /* open each encoder */
1733 for(i=0;i<nb_ostreams;i++) {
1735 if (ost->encoding_needed) {
1737 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1739 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1740 ost->file_index, ost->index);
1743 if (avcodec_open(ost->st->codec, codec) < 0) {
1744 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1745 ost->file_index, ost->index);
1748 extra_size += ost->st->codec->extradata_size;
1752 /* open each decoder */
1753 for(i=0;i<nb_istreams;i++) {
1755 if (ist->decoding_needed) {
1757 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1759 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1760 ist->st->codec->codec_id, ist->file_index, ist->index);
1763 if (avcodec_open(ist->st->codec, codec) < 0) {
1764 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1765 ist->file_index, ist->index);
1768 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1769 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1774 for(i=0;i<nb_istreams;i++) {
1776 is = input_files[ist->file_index];
1778 ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1779 if(ist->st->start_time == AV_NOPTS_VALUE)
1781 if(input_files_ts_offset[ist->file_index])
1782 ist->next_pts= AV_NOPTS_VALUE;
1786 /* compute buffer size max (should use a complete heuristic) */
1787 for(i=0;i<nb_input_files;i++) {
1788 file_table[i].buffer_size_max = 2048;
1791 /* set meta data information from input file if required */
1792 for (i=0;i<nb_meta_data_maps;i++) {
1793 AVFormatContext *out_file;
1794 AVFormatContext *in_file;
1796 int out_file_index = meta_data_maps[i].out_file;
1797 int in_file_index = meta_data_maps[i].in_file;
1798 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1799 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1803 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1804 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1809 out_file = output_files[out_file_index];
1810 in_file = input_files[in_file_index];
1812 strcpy(out_file->title, in_file->title);
1813 strcpy(out_file->author, in_file->author);
1814 strcpy(out_file->copyright, in_file->copyright);
1815 strcpy(out_file->comment, in_file->comment);
1816 strcpy(out_file->album, in_file->album);
1817 out_file->year = in_file->year;
1818 out_file->track = in_file->track;
1819 strcpy(out_file->genre, in_file->genre);
1822 /* open files and write file headers */
1823 for(i=0;i<nb_output_files;i++) {
1824 os = output_files[i];
1825 if (av_write_header(os) < 0) {
1826 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1832 if ( !using_stdin && verbose >= 0) {
1833 fprintf(stderr, "Press [q] to stop encoding\n");
1834 url_set_interrupt_cb(decode_interrupt_cb);
1841 for(; received_sigterm == 0;) {
1842 int file_index, ist_index;
1850 /* if 'q' pressed, exits */
1854 /* read_key() returns 0 on EOF */
1860 /* select the stream that we must read now by looking at the
1861 smallest output pts */
1863 for(i=0;i<nb_ostreams;i++) {
1866 os = output_files[ost->file_index];
1867 ist = ist_table[ost->source_index];
1868 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1869 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1871 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1872 ipts = (double)ist->pts;
1873 if (!file_table[ist->file_index].eof_reached){
1874 if(ipts < ipts_min) {
1876 if(input_sync ) file_index = ist->file_index;
1878 if(opts < opts_min) {
1880 if(!input_sync) file_index = ist->file_index;
1883 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1888 /* if none, if is finished */
1889 if (file_index < 0) {
1893 /* finish if recording time exhausted */
1894 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1897 /* finish if limit size exhausted */
1898 if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1901 /* read a frame from it and output it in the fifo */
1902 is = input_files[file_index];
1903 if (av_read_frame(is, &pkt) < 0) {
1904 file_table[file_index].eof_reached = 1;
1905 if (opt_shortest) break; else continue; //
1909 stream_no_data = is;
1914 av_pkt_dump(stdout, &pkt, do_hex_dump);
1916 /* the following test is needed in case new streams appear
1917 dynamically in stream : we ignore them */
1918 if (pkt.stream_index >= file_table[file_index].nb_streams)
1919 goto discard_packet;
1920 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1921 ist = ist_table[ist_index];
1923 goto discard_packet;
1925 // 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);
1926 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1927 int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1928 if(FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1929 input_files_ts_offset[ist->file_index]-= delta;
1931 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1932 for(i=0; i<file_table[file_index].nb_streams; i++){
1933 int index= file_table[file_index].ist_index + i;
1934 ist_table[index]->next_pts += delta;
1935 ist_table[index]->is_start=1;
1940 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1941 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1944 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1945 ist->file_index, ist->index);
1947 av_free_packet(&pkt);
1952 av_free_packet(&pkt);
1954 /* dump report by using the output first video and audio streams */
1955 print_report(output_files, ost_table, nb_ostreams, 0);
1958 /* at the end of stream, we must flush the decoder buffers */
1959 for(i=0;i<nb_istreams;i++) {
1961 if (ist->decoding_needed) {
1962 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1968 /* write the trailer if needed and close file */
1969 for(i=0;i<nb_output_files;i++) {
1970 os = output_files[i];
1971 av_write_trailer(os);
1974 /* dump report by using the first video and audio streams */
1975 print_report(output_files, ost_table, nb_ostreams, 1);
1977 /* close each encoder */
1978 for(i=0;i<nb_ostreams;i++) {
1980 if (ost->encoding_needed) {
1981 av_freep(&ost->st->codec->stats_in);
1982 avcodec_close(ost->st->codec);
1986 /* close each decoder */
1987 for(i=0;i<nb_istreams;i++) {
1989 if (ist->decoding_needed) {
1990 avcodec_close(ist->st->codec);
1998 av_freep(&bit_buffer);
1999 av_free(file_table);
2002 for(i=0;i<nb_istreams;i++) {
2009 for(i=0;i<nb_ostreams;i++) {
2013 fclose(ost->logfile);
2014 ost->logfile = NULL;
2016 av_fifo_free(&ost->fifo); /* works even if fifo is not
2017 initialized but set to zero */
2018 av_free(ost->pict_tmp.data[0]);
2019 if (ost->video_resample)
2020 sws_freeContext(ost->img_resample_ctx);
2021 if (ost->audio_resample)
2022 audio_resample_close(ost->resample);
2035 int file_read(const char *filename)
2038 unsigned char buffer[1024];
2041 if (url_open(&h, filename, O_RDONLY) < 0) {
2042 printf("could not open '%s'\n", filename);
2046 len = url_read(h, buffer, sizeof(buffer));
2049 for(i=0;i<len;i++) putchar(buffer[i]);
2056 static void opt_format(const char *arg)
2058 /* compatibility stuff for pgmyuv */
2059 if (!strcmp(arg, "pgmyuv")) {
2060 pgmyuv_compatibility_hack=1;
2061 // opt_image_format(arg);
2065 file_iformat = av_find_input_format(arg);
2066 file_oformat = guess_format(arg, NULL, NULL);
2067 if (!file_iformat && !file_oformat) {
2068 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2073 static void opt_video_rc_eq(char *arg)
2078 static void opt_video_rc_override_string(char *arg)
2080 video_rc_override_string = arg;
2083 static void opt_me_threshold(const char *arg)
2085 me_threshold = atoi(arg);
2088 static void opt_verbose(const char *arg)
2090 verbose = atoi(arg);
2091 av_log_level = atoi(arg);
2094 static void opt_frame_rate(const char *arg)
2096 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2097 fprintf(stderr, "Incorrect frame rate\n");
2102 static void opt_frame_crop_top(const char *arg)
2104 frame_topBand = atoi(arg);
2105 if (frame_topBand < 0) {
2106 fprintf(stderr, "Incorrect top crop size\n");
2109 if ((frame_topBand % 2) != 0) {
2110 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2113 if ((frame_topBand) >= frame_height){
2114 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2117 frame_height -= frame_topBand;
2120 static void opt_frame_crop_bottom(const char *arg)
2122 frame_bottomBand = atoi(arg);
2123 if (frame_bottomBand < 0) {
2124 fprintf(stderr, "Incorrect bottom crop size\n");
2127 if ((frame_bottomBand % 2) != 0) {
2128 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2131 if ((frame_bottomBand) >= frame_height){
2132 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2135 frame_height -= frame_bottomBand;
2138 static void opt_frame_crop_left(const char *arg)
2140 frame_leftBand = atoi(arg);
2141 if (frame_leftBand < 0) {
2142 fprintf(stderr, "Incorrect left crop size\n");
2145 if ((frame_leftBand % 2) != 0) {
2146 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2149 if ((frame_leftBand) >= frame_width){
2150 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2153 frame_width -= frame_leftBand;
2156 static void opt_frame_crop_right(const char *arg)
2158 frame_rightBand = atoi(arg);
2159 if (frame_rightBand < 0) {
2160 fprintf(stderr, "Incorrect right crop size\n");
2163 if ((frame_rightBand % 2) != 0) {
2164 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2167 if ((frame_rightBand) >= frame_width){
2168 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2171 frame_width -= frame_rightBand;
2174 static void opt_frame_size(const char *arg)
2176 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2177 fprintf(stderr, "Incorrect frame size\n");
2180 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2181 fprintf(stderr, "Frame size must be a multiple of 2\n");
2187 #define SCALEBITS 10
2188 #define ONE_HALF (1 << (SCALEBITS - 1))
2189 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2191 #define RGB_TO_Y(r, g, b) \
2192 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2193 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2195 #define RGB_TO_U(r1, g1, b1, shift)\
2196 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2197 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2199 #define RGB_TO_V(r1, g1, b1, shift)\
2200 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2201 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2203 static void opt_pad_color(const char *arg) {
2204 /* Input is expected to be six hex digits similar to
2205 how colors are expressed in html tags (but without the #) */
2206 int rgb = strtol(arg, NULL, 16);
2210 g = ((rgb >> 8) & 255);
2213 padcolor[0] = RGB_TO_Y(r,g,b);
2214 padcolor[1] = RGB_TO_U(r,g,b,0);
2215 padcolor[2] = RGB_TO_V(r,g,b,0);
2218 static void opt_frame_pad_top(const char *arg)
2220 frame_padtop = atoi(arg);
2221 if (frame_padtop < 0) {
2222 fprintf(stderr, "Incorrect top pad size\n");
2225 if ((frame_padtop % 2) != 0) {
2226 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2231 static void opt_frame_pad_bottom(const char *arg)
2233 frame_padbottom = atoi(arg);
2234 if (frame_padbottom < 0) {
2235 fprintf(stderr, "Incorrect bottom pad size\n");
2238 if ((frame_padbottom % 2) != 0) {
2239 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2245 static void opt_frame_pad_left(const char *arg)
2247 frame_padleft = atoi(arg);
2248 if (frame_padleft < 0) {
2249 fprintf(stderr, "Incorrect left pad size\n");
2252 if ((frame_padleft % 2) != 0) {
2253 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2259 static void opt_frame_pad_right(const char *arg)
2261 frame_padright = atoi(arg);
2262 if (frame_padright < 0) {
2263 fprintf(stderr, "Incorrect right pad size\n");
2266 if ((frame_padright % 2) != 0) {
2267 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2273 static void opt_frame_pix_fmt(const char *arg)
2275 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2278 static void opt_frame_aspect_ratio(const char *arg)
2284 p = strchr(arg, ':');
2286 x = strtol(arg, (char **)&arg, 10);
2288 y = strtol(arg+1, (char **)&arg, 10);
2290 ar = (double)x / (double)y;
2292 ar = strtod(arg, (char **)&arg);
2295 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2298 frame_aspect_ratio = ar;
2301 static void opt_qscale(const char *arg)
2303 video_qscale = atof(arg);
2304 if (video_qscale <= 0 ||
2305 video_qscale > 255) {
2306 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2311 static void opt_qdiff(const char *arg)
2313 video_qdiff = atoi(arg);
2314 if (video_qdiff < 0 ||
2316 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2321 static void opt_packet_size(const char *arg)
2323 packet_size= atoi(arg);
2326 static void opt_strict(const char *arg)
2331 static void opt_top_field_first(const char *arg)
2333 top_field_first= atoi(arg);
2336 static void opt_thread_count(const char *arg)
2338 thread_count= atoi(arg);
2339 #if !defined(HAVE_THREADS)
2341 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2345 static void opt_audio_bitrate(const char *arg)
2347 audio_bit_rate = atoi(arg) * 1000;
2350 static void opt_audio_rate(const char *arg)
2352 audio_sample_rate = atoi(arg);
2355 static void opt_audio_channels(const char *arg)
2357 audio_channels = atoi(arg);
2360 static void opt_video_device(const char *arg)
2362 video_device = av_strdup(arg);
2365 static void opt_grab_device(const char *arg)
2367 grab_device = av_strdup(arg);
2370 static void opt_video_channel(const char *arg)
2372 video_channel = strtol(arg, NULL, 0);
2375 static void opt_video_standard(const char *arg)
2377 video_standard = av_strdup(arg);
2380 static void opt_audio_device(const char *arg)
2382 audio_device = av_strdup(arg);
2385 static void opt_codec(int *pstream_copy, int *pcodec_id,
2386 int codec_type, const char *arg)
2390 if (!strcmp(arg, "copy")) {
2395 if (!strcmp(p->name, arg) && p->type == codec_type)
2400 fprintf(stderr, "Unknown codec '%s'\n", arg);
2408 static void opt_audio_codec(const char *arg)
2410 opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2413 static void opt_audio_tag(const char *arg)
2416 audio_codec_tag= strtol(arg, &tail, 0);
2419 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2422 static void opt_video_tag(const char *arg)
2425 video_codec_tag= strtol(arg, &tail, 0);
2428 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2431 static void add_frame_hooker(const char *arg)
2436 char *args = av_strdup(arg);
2440 argv[0] = strtok(args, " ");
2441 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2444 i = frame_hook_add(argc, argv);
2447 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2452 const char *motion_str[] = {
2465 static void opt_motion_estimation(const char *arg)
2471 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2474 if (!strcmp(*p, arg))
2478 me_method = (p - motion_str) + 1;
2481 static void opt_video_codec(const char *arg)
2483 opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2486 static void opt_subtitle_codec(const char *arg)
2488 opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2491 static void opt_map(const char *arg)
2497 m = &stream_maps[nb_stream_maps++];
2499 m->file_index = strtol(arg, (char **)&p, 0);
2503 m->stream_index = strtol(p, (char **)&p, 0);
2506 m->sync_file_index = strtol(p, (char **)&p, 0);
2509 m->sync_stream_index = strtol(p, (char **)&p, 0);
2511 m->sync_file_index = m->file_index;
2512 m->sync_stream_index = m->stream_index;
2516 static void opt_map_meta_data(const char *arg)
2522 m = &meta_data_maps[nb_meta_data_maps++];
2524 m->out_file = strtol(arg, (char **)&p, 0);
2528 m->in_file = strtol(p, (char **)&p, 0);
2531 static void opt_recording_time(const char *arg)
2533 recording_time = parse_date(arg, 1);
2536 static void opt_start_time(const char *arg)
2538 start_time = parse_date(arg, 1);
2541 static void opt_rec_timestamp(const char *arg)
2543 rec_timestamp = parse_date(arg, 0) / 1000000;
2546 static void opt_input_ts_offset(const char *arg)
2548 input_ts_offset = parse_date(arg, 1);
2551 static void opt_input_file(const char *filename)
2553 AVFormatContext *ic;
2554 AVFormatParameters params, *ap = ¶ms;
2555 int err, i, ret, rfps, rfps_base;
2558 if (!strcmp(filename, "-"))
2561 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2562 !strcmp( filename, "/dev/stdin" );
2564 /* get default parameters from command line */
2565 ic = av_alloc_format_context();
2567 memset(ap, 0, sizeof(*ap));
2568 ap->prealloced_context = 1;
2569 ap->sample_rate = audio_sample_rate;
2570 ap->channels = audio_channels;
2571 ap->time_base.den = frame_rate;
2572 ap->time_base.num = frame_rate_base;
2573 ap->width = frame_width + frame_padleft + frame_padright;
2574 ap->height = frame_height + frame_padtop + frame_padbottom;
2575 ap->pix_fmt = frame_pix_fmt;
2576 ap->device = grab_device;
2577 ap->channel = video_channel;
2578 ap->standard = video_standard;
2579 ap->video_codec_id = video_codec_id;
2580 ap->audio_codec_id = audio_codec_id;
2581 if(pgmyuv_compatibility_hack)
2582 ap->video_codec_id= CODEC_ID_PGMYUV;
2584 for(i=0; i<opt_name_count; i++){
2585 const AVOption *opt;
2586 double d= av_get_double(avformat_opts, opt_names[i], &opt);
2587 if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2588 av_set_double(ic, opt_names[i], d);
2590 /* open the input file with generic libav function */
2591 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2593 print_error(filename, err);
2597 ic->loop_input = loop_input;
2599 /* If not enough info to get the stream parameters, we decode the
2600 first frames to get it. (used in mpeg case for example) */
2601 ret = av_find_stream_info(ic);
2602 if (ret < 0 && verbose >= 0) {
2603 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2607 timestamp = start_time;
2608 /* add the stream start time */
2609 if (ic->start_time != AV_NOPTS_VALUE)
2610 timestamp += ic->start_time;
2612 /* if seeking requested, we execute it */
2613 if (start_time != 0) {
2614 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2616 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2617 filename, (double)timestamp / AV_TIME_BASE);
2619 /* reset seek info */
2623 /* update the current parameters so that they match the one of the input stream */
2624 for(i=0;i<ic->nb_streams;i++) {
2626 AVCodecContext *enc = ic->streams[i]->codec;
2627 #if defined(HAVE_THREADS)
2629 avcodec_thread_init(enc, thread_count);
2631 enc->thread_count= thread_count;
2632 switch(enc->codec_type) {
2633 case CODEC_TYPE_AUDIO:
2634 for(j=0; j<opt_name_count; j++){
2635 const AVOption *opt;
2636 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2637 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2638 av_set_double(enc, opt_names[j], d);
2640 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2641 audio_channels = enc->channels;
2642 audio_sample_rate = enc->sample_rate;
2644 ic->streams[i]->discard= AVDISCARD_ALL;
2646 case CODEC_TYPE_VIDEO:
2647 for(j=0; j<opt_name_count; j++){
2648 const AVOption *opt;
2649 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2650 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2651 av_set_double(enc, opt_names[j], d);
2653 frame_height = enc->height;
2654 frame_width = enc->width;
2655 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2656 frame_pix_fmt = enc->pix_fmt;
2657 rfps = ic->streams[i]->r_frame_rate.num;
2658 rfps_base = ic->streams[i]->r_frame_rate.den;
2659 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2661 enc->debug |= FF_DEBUG_MV;
2663 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2666 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2667 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2669 (float)rfps / rfps_base, rfps, rfps_base);
2671 /* update the current frame rate to match the stream frame rate */
2673 frame_rate_base = rfps_base;
2675 enc->rate_emu = rate_emu;
2677 ic->streams[i]->discard= AVDISCARD_ALL;
2678 else if(video_discard)
2679 ic->streams[i]->discard= video_discard;
2681 case CODEC_TYPE_DATA:
2683 case CODEC_TYPE_SUBTITLE:
2685 case CODEC_TYPE_UNKNOWN:
2692 input_files[nb_input_files] = ic;
2693 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2694 /* dump the file content */
2696 dump_format(ic, nb_input_files, filename, 0);
2699 file_iformat = NULL;
2700 file_oformat = NULL;
2708 static void opt_grab(const char *arg)
2710 file_iformat = av_find_input_format(arg);
2714 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2716 int has_video, has_audio, i, j;
2717 AVFormatContext *ic;
2721 for(j=0;j<nb_input_files;j++) {
2722 ic = input_files[j];
2723 for(i=0;i<ic->nb_streams;i++) {
2724 AVCodecContext *enc = ic->streams[i]->codec;
2725 switch(enc->codec_type) {
2726 case CODEC_TYPE_AUDIO:
2729 case CODEC_TYPE_VIDEO:
2732 case CODEC_TYPE_DATA:
2733 case CODEC_TYPE_UNKNOWN:
2734 case CODEC_TYPE_SUBTITLE:
2741 *has_video_ptr = has_video;
2742 *has_audio_ptr = has_audio;
2745 static void new_video_stream(AVFormatContext *oc)
2748 AVCodecContext *video_enc;
2751 st = av_new_stream(oc, oc->nb_streams);
2753 fprintf(stderr, "Could not alloc stream\n");
2756 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2757 video_bitstream_filters= NULL;
2759 #if defined(HAVE_THREADS)
2761 avcodec_thread_init(st->codec, thread_count);
2764 video_enc = st->codec;
2767 video_enc->codec_tag= video_codec_tag;
2769 if( (video_global_header&1)
2770 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2771 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2772 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2774 if(video_global_header&2){
2775 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2776 avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2779 if (video_stream_copy) {
2780 st->stream_copy = 1;
2781 video_enc->codec_type = CODEC_TYPE_VIDEO;
2787 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2788 if (video_codec_id != CODEC_ID_NONE)
2789 codec_id = video_codec_id;
2791 video_enc->codec_id = codec_id;
2792 codec = avcodec_find_encoder(codec_id);
2794 for(i=0; i<opt_name_count; i++){
2795 const AVOption *opt;
2796 double d= av_get_double(avctx_opts, opt_names[i], &opt);
2797 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2798 av_set_double(video_enc, opt_names[i], d);
2801 video_enc->time_base.den = frame_rate;
2802 video_enc->time_base.num = frame_rate_base;
2803 if(codec && codec->supported_framerates){
2804 const AVRational *p= codec->supported_framerates;
2805 AVRational req= (AVRational){frame_rate, frame_rate_base};
2806 const AVRational *best=NULL;
2807 AVRational best_error= (AVRational){INT_MAX, 1};
2808 for(; p->den!=0; p++){
2809 AVRational error= av_sub_q(req, *p);
2810 if(error.num <0) error.num *= -1;
2811 if(av_cmp_q(error, best_error) < 0){
2816 video_enc->time_base.den= best->num;
2817 video_enc->time_base.num= best->den;
2820 video_enc->width = frame_width + frame_padright + frame_padleft;
2821 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2822 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2823 video_enc->pix_fmt = frame_pix_fmt;
2825 if(codec && codec->pix_fmts){
2826 const enum PixelFormat *p= codec->pix_fmts;
2828 if(*p == video_enc->pix_fmt)
2832 video_enc->pix_fmt = codec->pix_fmts[0];
2836 video_enc->gop_size = 0;
2837 if (video_qscale || same_quality) {
2838 video_enc->flags |= CODEC_FLAG_QSCALE;
2839 video_enc->global_quality=
2840 st->quality = FF_QP2LAMBDA * video_qscale;
2844 video_enc->intra_matrix = intra_matrix;
2846 video_enc->inter_matrix = inter_matrix;
2848 video_enc->max_qdiff = video_qdiff;
2849 video_enc->rc_eq = video_rc_eq;
2850 video_enc->thread_count = thread_count;
2851 p= video_rc_override_string;
2854 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2856 fprintf(stderr, "error parsing rc_override\n");
2859 video_enc->rc_override=
2860 av_realloc(video_enc->rc_override,
2861 sizeof(RcOverride)*(i+1));
2862 video_enc->rc_override[i].start_frame= start;
2863 video_enc->rc_override[i].end_frame = end;
2865 video_enc->rc_override[i].qscale= q;
2866 video_enc->rc_override[i].quality_factor= 1.0;
2869 video_enc->rc_override[i].qscale= 0;
2870 video_enc->rc_override[i].quality_factor= -q/100.0;
2875 video_enc->rc_override_count=i;
2876 if (!video_enc->rc_initial_buffer_occupancy)
2877 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2878 video_enc->me_threshold= me_threshold;
2879 video_enc->intra_dc_precision= intra_dc_precision - 8;
2880 video_enc->strict_std_compliance = strict;
2883 video_enc->rtp_mode= 1;
2884 video_enc->rtp_payload_size= packet_size;
2888 video_enc->flags|= CODEC_FLAG_PSNR;
2890 video_enc->me_method = me_method;
2895 video_enc->flags |= CODEC_FLAG_PASS1;
2897 video_enc->flags |= CODEC_FLAG_PASS2;
2902 /* reset some key parameters */
2904 video_codec_id = CODEC_ID_NONE;
2905 video_stream_copy = 0;
2908 static void new_audio_stream(AVFormatContext *oc)
2911 AVCodecContext *audio_enc;
2914 st = av_new_stream(oc, oc->nb_streams);
2916 fprintf(stderr, "Could not alloc stream\n");
2920 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2921 audio_bitstream_filters= NULL;
2923 #if defined(HAVE_THREADS)
2925 avcodec_thread_init(st->codec, thread_count);
2928 audio_enc = st->codec;
2929 audio_enc->codec_type = CODEC_TYPE_AUDIO;
2930 audio_enc->strict_std_compliance = strict;
2933 audio_enc->codec_tag= audio_codec_tag;
2935 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2936 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2937 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2939 if (audio_stream_copy) {
2940 st->stream_copy = 1;
2941 audio_enc->channels = audio_channels;
2943 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2945 for(i=0; i<opt_name_count; i++){
2946 const AVOption *opt;
2947 double d= av_get_double(avctx_opts, opt_names[i], &opt);
2948 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2949 av_set_double(audio_enc, opt_names[i], d);
2952 if (audio_codec_id != CODEC_ID_NONE)
2953 codec_id = audio_codec_id;
2954 audio_enc->codec_id = codec_id;
2956 audio_enc->bit_rate = audio_bit_rate;
2957 if (audio_qscale > QSCALE_NONE) {
2958 audio_enc->flags |= CODEC_FLAG_QSCALE;
2959 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
2961 audio_enc->thread_count = thread_count;
2962 audio_enc->channels = audio_channels;
2964 audio_enc->sample_rate = audio_sample_rate;
2965 audio_enc->time_base= (AVRational){1, audio_sample_rate};
2966 if (audio_language) {
2967 pstrcpy(st->language, sizeof(st->language), audio_language);
2968 av_free(audio_language);
2969 audio_language = NULL;
2972 /* reset some key parameters */
2974 audio_codec_id = CODEC_ID_NONE;
2975 audio_stream_copy = 0;
2978 static void opt_new_subtitle_stream(void)
2980 AVFormatContext *oc;
2982 AVCodecContext *subtitle_enc;
2985 if (nb_output_files <= 0) {
2986 fprintf(stderr, "At least one output file must be specified\n");
2989 oc = output_files[nb_output_files - 1];
2991 st = av_new_stream(oc, oc->nb_streams);
2993 fprintf(stderr, "Could not alloc stream\n");
2997 subtitle_enc = st->codec;
2998 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
2999 if (subtitle_stream_copy) {
3000 st->stream_copy = 1;
3002 for(i=0; i<opt_name_count; i++){
3003 const AVOption *opt;
3004 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3005 if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3006 av_set_double(subtitle_enc, opt_names[i], d);
3008 subtitle_enc->codec_id = subtitle_codec_id;
3011 if (subtitle_language) {
3012 pstrcpy(st->language, sizeof(st->language), subtitle_language);
3013 av_free(subtitle_language);
3014 subtitle_language = NULL;
3017 subtitle_codec_id = CODEC_ID_NONE;
3018 subtitle_stream_copy = 0;
3021 static void opt_new_audio_stream(void)
3023 AVFormatContext *oc;
3024 if (nb_output_files <= 0) {
3025 fprintf(stderr, "At least one output file must be specified\n");
3028 oc = output_files[nb_output_files - 1];
3029 new_audio_stream(oc);
3032 static void opt_new_video_stream(void)
3034 AVFormatContext *oc;
3035 if (nb_output_files <= 0) {
3036 fprintf(stderr, "At least one output file must be specified\n");
3039 oc = output_files[nb_output_files - 1];
3040 new_video_stream(oc);
3043 static void opt_output_file(const char *filename)
3045 AVFormatContext *oc;
3046 int use_video, use_audio, input_has_video, input_has_audio, i;
3047 AVFormatParameters params, *ap = ¶ms;
3049 if (!strcmp(filename, "-"))
3052 oc = av_alloc_format_context();
3054 if (!file_oformat) {
3055 file_oformat = guess_format(NULL, filename, NULL);
3056 if (!file_oformat) {
3057 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3063 oc->oformat = file_oformat;
3064 pstrcpy(oc->filename, sizeof(oc->filename), filename);
3066 if (!strcmp(file_oformat->name, "ffm") &&
3067 strstart(filename, "http:", NULL)) {
3068 /* special case for files sent to ffserver: we get the stream
3069 parameters from ffserver */
3070 if (read_ffserver_streams(oc, filename) < 0) {
3071 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3075 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3076 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3078 /* disable if no corresponding type found and at least one
3080 if (nb_input_files > 0) {
3081 check_audio_video_inputs(&input_has_video, &input_has_audio);
3082 if (!input_has_video)
3084 if (!input_has_audio)
3088 /* manual disable */
3089 if (audio_disable) {
3092 if (video_disable) {
3097 new_video_stream(oc);
3101 new_audio_stream(oc);
3104 oc->timestamp = rec_timestamp;
3107 pstrcpy(oc->title, sizeof(oc->title), str_title);
3109 pstrcpy(oc->author, sizeof(oc->author), str_author);
3111 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3113 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3115 pstrcpy(oc->album, sizeof(oc->album), str_album);
3118 output_files[nb_output_files++] = oc;
3120 /* check filename in case of an image number is expected */
3121 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3122 if (!av_filename_number_test(oc->filename)) {
3123 print_error(oc->filename, AVERROR_NUMEXPECTED);
3128 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3129 /* test if it already exists to avoid loosing precious files */
3130 if (!file_overwrite &&
3131 (strchr(filename, ':') == NULL ||
3132 strstart(filename, "file:", NULL))) {
3133 if (url_exist(filename)) {
3136 if ( !using_stdin ) {
3137 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3140 if (toupper(c) != 'Y') {
3141 fprintf(stderr, "Not overwriting - exiting\n");
3146 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3153 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3154 fprintf(stderr, "Could not open '%s'\n", filename);
3159 memset(ap, 0, sizeof(*ap));
3160 if (av_set_parameters(oc, ap) < 0) {
3161 fprintf(stderr, "%s: Invalid encoding parameters\n",
3166 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3167 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3168 oc->loop_output = loop_output;
3170 for(i=0; i<opt_name_count; i++){
3171 const AVOption *opt;
3172 double d = av_get_double(avformat_opts, opt_names[i], &opt);
3173 if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3174 av_set_double(oc, opt_names[i], d);
3177 /* reset some options */
3178 file_oformat = NULL;
3179 file_iformat = NULL;
3182 /* prepare dummy protocols for grab */
3183 static void prepare_grab(void)
3185 int has_video, has_audio, i, j;
3186 AVFormatContext *oc;
3187 AVFormatContext *ic;
3188 AVFormatParameters vp1, *vp = &vp1;
3189 AVFormatParameters ap1, *ap = &ap1;
3191 /* see if audio/video inputs are needed */
3194 memset(ap, 0, sizeof(*ap));
3195 memset(vp, 0, sizeof(*vp));
3196 vp->time_base.num= 1;
3197 for(j=0;j<nb_output_files;j++) {
3198 oc = output_files[j];
3199 for(i=0;i<oc->nb_streams;i++) {
3200 AVCodecContext *enc = oc->streams[i]->codec;
3201 switch(enc->codec_type) {
3202 case CODEC_TYPE_AUDIO:
3203 if (enc->sample_rate > ap->sample_rate)
3204 ap->sample_rate = enc->sample_rate;
3205 if (enc->channels > ap->channels)
3206 ap->channels = enc->channels;
3209 case CODEC_TYPE_VIDEO:
3210 if (enc->width > vp->width)
3211 vp->width = enc->width;
3212 if (enc->height > vp->height)
3213 vp->height = enc->height;
3215 if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3216 vp->time_base = enc->time_base;
3217 vp->width += frame_leftBand + frame_rightBand;
3218 vp->width -= (frame_padleft + frame_padright);
3219 vp->height += frame_topBand + frame_bottomBand;
3220 vp->height -= (frame_padtop + frame_padbottom);
3230 if (has_video == 0 && has_audio == 0) {
3231 fprintf(stderr, "Output file must have at least one audio or video stream\n");
3236 AVInputFormat *fmt1;
3237 #warning FIXME: find a better interface
3238 if(video_device&&!strncmp(video_device,"x11:",4)) {
3239 video_grab_format="x11grab";
3241 fmt1 = av_find_input_format(video_grab_format);
3242 vp->device = video_device;
3243 vp->channel = video_channel;
3244 vp->standard = video_standard;
3245 vp->pix_fmt = frame_pix_fmt;
3246 if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3247 fprintf(stderr, "Could not find video grab device\n");
3250 /* If not enough info to get the stream parameters, we decode the
3251 first frames to get it. */
3252 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3253 fprintf(stderr, "Could not find video grab parameters\n");
3256 /* by now video grab has one stream */
3257 ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3258 ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3259 input_files[nb_input_files] = ic;
3262 dump_format(ic, nb_input_files, "", 0);
3266 if (has_audio && audio_grab_format) {
3267 AVInputFormat *fmt1;
3268 fmt1 = av_find_input_format(audio_grab_format);
3269 ap->device = audio_device;
3270 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3271 fprintf(stderr, "Could not find audio grab device\n");
3274 input_files[nb_input_files] = ic;
3277 dump_format(ic, nb_input_files, "", 0);
3283 /* same option as mencoder */
3284 static void opt_pass(const char *pass_str)
3287 pass = atoi(pass_str);
3288 if (pass != 1 && pass != 2) {
3289 fprintf(stderr, "pass number can be only 1 or 2\n");
3295 #if defined(__MINGW32__) || defined(CONFIG_OS2)
3296 static int64_t getutime(void)
3298 return av_gettime();
3301 static int64_t getutime(void)
3303 struct rusage rusage;
3305 getrusage(RUSAGE_SELF, &rusage);
3306 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3310 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3311 extern int ffm_nopts;
3314 static void show_formats(void)
3316 AVInputFormat *ifmt;
3317 AVOutputFormat *ofmt;
3320 const char **pp, *last_name;
3322 printf("File formats:\n");
3327 const char *name=NULL;
3328 const char *long_name=NULL;
3330 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3331 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3332 strcmp(ofmt->name, last_name)>0){
3334 long_name= ofmt->long_name;
3338 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3339 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3340 strcmp(ifmt->name, last_name)>0){
3342 long_name= ifmt->long_name;
3345 if(name && strcmp(ifmt->name, name)==0)
3357 long_name ? long_name:" ");
3361 printf("Codecs:\n");
3367 const char *type_str;
3370 for(p = first_avcodec; p != NULL; p = p->next) {
3371 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3372 strcmp(p->name, last_name)>0){
3374 decode= encode= cap=0;
3376 if(p2 && strcmp(p->name, p2->name)==0){
3377 if(p->decode) decode=1;
3378 if(p->encode) encode=1;
3379 cap |= p->capabilities;
3384 last_name= p2->name;
3387 case CODEC_TYPE_VIDEO:
3390 case CODEC_TYPE_AUDIO:
3393 case CODEC_TYPE_SUBTITLE:
3402 decode ? "D": (/*p2->decoder ? "d":*/" "),
3405 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3406 cap & CODEC_CAP_DR1 ? "D":" ",
3407 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3409 /* if(p2->decoder && decode==0)
3410 printf(" use %s for decoding", p2->decoder->name);*/
3415 printf("Supported file protocols:\n");
3416 for(up = first_protocol; up != NULL; up = up->next)
3417 printf(" %s:", up->name);
3420 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3421 printf("Motion estimation methods:\n");
3425 if ((pp - motion_str + 1) == ME_ZERO)
3426 printf("(fastest)");
3427 else if ((pp - motion_str + 1) == ME_FULL)
3428 printf("(slowest)");
3429 else if ((pp - motion_str + 1) == ME_EPZS)
3430 printf("(default)");
3435 "Note, the names of encoders and decoders dont always match, so there are\n"
3436 "several cases where the above table shows encoder only or decoder only entries\n"
3437 "even though both encoding and decoding are supported for example, the h263\n"
3438 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3443 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3446 const char *p = str;
3453 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3460 static void opt_inter_matrix(const char *arg)
3462 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3463 parse_matrix_coeffs(inter_matrix, arg);
3466 static void opt_intra_matrix(const char *arg)
3468 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3469 parse_matrix_coeffs(intra_matrix, arg);
3472 static void opt_target(const char *arg)
3475 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3477 if(!strncmp(arg, "pal-", 4)) {
3480 } else if(!strncmp(arg, "ntsc-", 5)) {
3483 } else if(!strncmp(arg, "film-", 5)) {
3488 /* Calculate FR via float to avoid int overflow */
3489 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3492 } else if((fr == 29970) || (fr == 23976)) {
3495 /* Try to determine PAL/NTSC by peeking in the input files */
3496 if(nb_input_files) {
3498 for(j = 0; j < nb_input_files; j++) {
3499 for(i = 0; i < input_files[j]->nb_streams; i++) {
3500 AVCodecContext *c = input_files[j]->streams[i]->codec;
3501 if(c->codec_type != CODEC_TYPE_VIDEO)
3503 fr = c->time_base.den * 1000 / c->time_base.num;
3507 } else if((fr == 29970) || (fr == 23976)) {
3517 if(verbose && norm >= 0)
3518 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3522 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3523 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3524 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3528 if(!strcmp(arg, "vcd")) {
3530 opt_video_codec("mpeg1video");
3531 opt_audio_codec("mp2");
3534 opt_frame_size(norm ? "352x240" : "352x288");
3535 opt_frame_rate(frame_rates[norm]);
3536 opt_default("gop", norm ? "18" : "15");
3538 opt_default("b", "1150000");
3539 opt_default("maxrate", "1150000");
3540 opt_default("minrate", "1150000");
3541 opt_default("bufsize", "327680"); // 40*1024*8;
3543 audio_bit_rate = 224000;
3544 audio_sample_rate = 44100;
3547 opt_default("packetsize", "2324");
3548 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3550 /* We have to offset the PTS, so that it is consistent with the SCR.
3551 SCR starts at 36000, but the first two packs contain only padding
3552 and the first pack from the other stream, respectively, may also have
3553 been written before.
3554 So the real data starts at SCR 36000+3*1200. */
3555 mux_preload= (36000+3*1200) / 90000.0; //0.44
3556 } else if(!strcmp(arg, "svcd")) {
3558 opt_video_codec("mpeg2video");
3559 opt_audio_codec("mp2");
3562 opt_frame_size(norm ? "480x480" : "480x576");
3563 opt_frame_rate(frame_rates[norm]);
3564 opt_default("gop", norm ? "18" : "15");
3566 opt_default("b", "2040000");
3567 opt_default("maxrate", "2516000");
3568 opt_default("minrate", "0"); //1145000;
3569 opt_default("bufsize", "1835008"); //224*1024*8;
3570 opt_default("flags", "+SCAN_OFFSET");
3573 audio_bit_rate = 224000;
3574 audio_sample_rate = 44100;
3576 opt_default("packetsize", "2324");
3578 } else if(!strcmp(arg, "dvd")) {
3580 opt_video_codec("mpeg2video");
3581 opt_audio_codec("ac3");
3584 opt_frame_size(norm ? "720x480" : "720x576");
3585 opt_frame_rate(frame_rates[norm]);
3586 opt_default("gop", norm ? "18" : "15");
3588 opt_default("b", "6000000");
3589 opt_default("maxrate", "9000000");
3590 opt_default("minrate", "0"); //1500000;
3591 opt_default("bufsize", "1835008"); //224*1024*8;
3593 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3594 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3596 audio_bit_rate = 448000;
3597 audio_sample_rate = 48000;
3599 } else if(!strncmp(arg, "dv", 2)) {
3603 opt_frame_size(norm ? "720x480" : "720x576");
3604 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3605 (norm ? "yuv411p" : "yuv420p"));
3606 opt_frame_rate(frame_rates[norm]);
3608 audio_sample_rate = 48000;
3612 fprintf(stderr, "Unknown target: %s\n", arg);
3617 static void opt_video_bsf(const char *arg)
3619 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3620 AVBitStreamFilterContext **bsfp;
3623 fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3627 bsfp= &video_bitstream_filters;
3629 bsfp= &(*bsfp)->next;
3634 //FIXME avoid audio - video code duplication
3635 static void opt_audio_bsf(const char *arg)
3637 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3638 AVBitStreamFilterContext **bsfp;
3641 fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3645 bsfp= &audio_bitstream_filters;
3647 bsfp= &(*bsfp)->next;
3652 static void show_version(void)
3654 /* TODO: add function interface to avutil and avformat */
3655 fprintf(stderr, "ffmpeg " FFMPEG_VERSION "\n"
3659 LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3663 static int opt_default(const char *opt, const char *arg){
3664 const AVOption *o= av_set_string(avctx_opts, opt, arg);
3666 o = av_set_string(avformat_opts, opt, arg);
3670 // 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));
3672 //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3673 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3674 opt_names[opt_name_count++]= o->name;
3676 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3677 /* disable generate of real time pts in ffm (need to be supressed anyway) */
3678 if(avctx_opts->flags & CODEC_FLAG_BITEXACT)
3682 if(avctx_opts->debug)
3683 av_log_level = AV_LOG_DEBUG;
3687 const OptionDef options[] = {
3689 { "L", 0, {(void*)show_license}, "show license" },
3690 { "h", 0, {(void*)show_help}, "show help" },
3691 { "version", 0, {(void*)show_version}, "show version" },
3692 { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3693 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3694 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3695 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3696 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3697 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3698 { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3699 { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
3700 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3701 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3702 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3703 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3704 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3705 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3706 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3707 { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3708 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3709 "add timings for benchmarking" },
3710 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3711 "dump each input packet" },
3712 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3713 "when dumping packets, also dump the payload" },
3714 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3715 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3716 { "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)", "" },
3717 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3718 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3719 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3720 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3721 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3722 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3723 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3724 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3725 { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3728 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3729 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3730 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3731 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3732 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3733 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3734 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3735 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3736 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3737 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3738 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3739 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3740 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3741 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3742 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3743 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3744 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3745 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3746 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3747 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3748 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
3749 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3750 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3751 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3752 { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3754 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
3755 { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
3756 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3757 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3758 "use same video quality as source (implies VBR)" },
3759 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3760 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3761 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3762 "deinterlace pictures" },
3763 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3764 { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
3765 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3766 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3767 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3768 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3769 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3770 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3771 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3772 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3775 { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
3776 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3777 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3778 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3779 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3780 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3781 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3782 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3783 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3784 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3786 /* subtitle options */
3787 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3788 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3789 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3792 { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
3793 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3794 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3795 { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
3797 /* G.2 grab options */
3798 { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
3799 { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
3802 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3803 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3805 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
3806 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
3808 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3812 static void show_banner(void)
3814 fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2007 Fabrice Bellard, et al.\n");
3815 fprintf(stderr, " configuration: " FFMPEG_CONFIGURATION "\n");
3816 fprintf(stderr, " libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
3817 fprintf(stderr, " libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
3818 fprintf(stderr, " libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
3819 fprintf(stderr, " built on " __DATE__ " " __TIME__);
3821 fprintf(stderr, ", gcc: " __VERSION__ "\n");
3823 fprintf(stderr, ", using a non-gcc compiler\n");
3827 static void show_license(void)
3832 "FFmpeg is free software; you can redistribute it and/or modify\n"
3833 "it under the terms of the GNU General Public License as published by\n"
3834 "the Free Software Foundation; either version 2 of the License, or\n"
3835 "(at your option) any later version.\n"
3837 "FFmpeg is distributed in the hope that it will be useful,\n"
3838 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3839 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
3840 "GNU General Public License for more details.\n"
3842 "You should have received a copy of the GNU General Public License\n"
3843 "along with FFmpeg; if not, write to the Free Software\n"
3844 "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
3848 "FFmpeg is free software; you can redistribute it and/or\n"
3849 "modify it under the terms of the GNU Lesser General Public\n"
3850 "License as published by the Free Software Foundation; either\n"
3851 "version 2.1 of the License, or (at your option) any later version.\n"
3853 "FFmpeg is distributed in the hope that it will be useful,\n"
3854 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3855 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
3856 "Lesser General Public License for more details.\n"
3858 "You should have received a copy of the GNU Lesser General Public\n"
3859 "License along with FFmpeg; if not, write to the Free Software\n"
3860 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
3866 static void show_help(void)
3869 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3870 "Hyper fast Audio and Video encoder\n");
3872 show_help_options(options, "Main options:\n",
3873 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3874 show_help_options(options, "\nVideo options:\n",
3875 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3877 show_help_options(options, "\nAdvanced Video options:\n",
3878 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3879 OPT_VIDEO | OPT_EXPERT);
3880 show_help_options(options, "\nAudio options:\n",
3881 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3883 show_help_options(options, "\nAdvanced Audio options:\n",
3884 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3885 OPT_AUDIO | OPT_EXPERT);
3886 show_help_options(options, "\nSubtitle options:\n",
3887 OPT_SUBTITLE | OPT_GRAB,
3889 show_help_options(options, "\nAudio/Video grab options:\n",
3892 show_help_options(options, "\nAdvanced options:\n",
3893 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3895 av_opt_show(avctx_opts, NULL);
3896 av_opt_show(avformat_opts, NULL);
3901 void parse_arg_file(const char *filename)
3903 opt_output_file(filename);
3906 int main(int argc, char **argv)
3913 avctx_opts= avcodec_alloc_context();
3914 avformat_opts = av_alloc_format_context();
3922 parse_options(argc, argv, options);
3924 /* file converter / grab */
3925 if (nb_output_files <= 0) {
3926 fprintf(stderr, "Must supply at least one output file\n");
3930 if (nb_input_files == 0) {
3936 av_encode(output_files, nb_output_files, input_files, nb_input_files,
3937 stream_maps, nb_stream_maps);
3938 ti = getutime() - ti;
3940 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3944 for(i=0;i<nb_output_files;i++) {
3945 /* maybe av_close_output_file ??? */
3946 AVFormatContext *s = output_files[i];
3948 if (!(s->oformat->flags & AVFMT_NOFILE))
3950 for(j=0;j<s->nb_streams;j++) {
3951 av_free(s->streams[j]->codec);
3952 av_free(s->streams[j]);
3956 for(i=0;i<nb_input_files;i++)
3957 av_close_input_file(input_files[i]);
3962 av_free(intra_matrix);
3964 av_free(inter_matrix);
3966 #ifdef POWERPC_PERFORMANCE_REPORT
3967 extern void powerpc_display_perf_report(void);
3968 powerpc_display_perf_report();
3969 #endif /* POWERPC_PERFORMANCE_REPORT */
3971 if (received_sigterm) {
3973 "Received signal %d: terminating.\n",
3974 (int) received_sigterm);
3978 exit(0); /* not all OS-es handle main() return value */