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"
35 #include <sys/ioctl.h>
38 #include <sys/resource.h>
41 #include <sys/types.h>
42 #include <sys/select.h>
45 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
54 #if !defined(INFINITY) && defined(HUGE_VAL)
55 #define INFINITY HUGE_VAL
60 /* select an input stream for an output stream */
61 typedef struct AVStreamMap {
65 int sync_stream_index;
68 /** select an input file for an output file */
69 typedef struct AVMetaDataMap {
74 extern const OptionDef options[];
76 static void show_help(void);
77 static void show_license(void);
78 static int opt_default(const char *opt, const char *arg);
82 static AVFormatContext *input_files[MAX_FILES];
83 static int64_t input_files_ts_offset[MAX_FILES];
84 static int nb_input_files = 0;
86 static AVFormatContext *output_files[MAX_FILES];
87 static int nb_output_files = 0;
89 static AVStreamMap stream_maps[MAX_FILES];
90 static int nb_stream_maps;
92 static AVMetaDataMap meta_data_maps[MAX_FILES];
93 static int nb_meta_data_maps;
95 static AVInputFormat *file_iformat;
96 static AVOutputFormat *file_oformat;
97 static int frame_width = 0;
98 static int frame_height = 0;
99 static float frame_aspect_ratio = 0;
100 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
101 static int frame_padtop = 0;
102 static int frame_padbottom = 0;
103 static int frame_padleft = 0;
104 static int frame_padright = 0;
105 static int padcolor[3] = {16,128,128}; /* default to black */
106 static int frame_topBand = 0;
107 static int frame_bottomBand = 0;
108 static int frame_leftBand = 0;
109 static int frame_rightBand = 0;
110 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
111 static int frame_rate = 25;
112 static int frame_rate_base = 1;
113 static float video_qscale = 0;
114 static int video_qdiff = 3;
115 static uint16_t *intra_matrix = NULL;
116 static uint16_t *inter_matrix = NULL;
117 #if 0 //experimental, (can be removed)
118 static float video_rc_qsquish=1.0;
119 static float video_rc_qmod_amp=0;
120 static int video_rc_qmod_freq=0;
122 static char *video_rc_override_string=NULL;
123 static char *video_rc_eq="tex^qComp";
124 static int me_method = ME_EPZS;
125 static int video_disable = 0;
126 static int video_discard = 0;
127 static int video_codec_id = CODEC_ID_NONE;
128 static int video_codec_tag = 0;
129 static int same_quality = 0;
130 static int do_deinterlace = 0;
131 static int 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 #define QSCALE_NONE -99999
142 static float audio_qscale = QSCALE_NONE;
143 static int audio_disable = 0;
144 static int audio_channels = 1;
145 static int audio_codec_id = CODEC_ID_NONE;
146 static int audio_codec_tag = 0;
147 static char *audio_language = NULL;
149 static int subtitle_codec_id = CODEC_ID_NONE;
150 static char *subtitle_language = NULL;
152 static float mux_preload= 0.5;
153 static float mux_max_delay= 0.7;
155 static int64_t recording_time = 0;
156 static int64_t start_time = 0;
157 static int64_t rec_timestamp = 0;
158 static int64_t input_ts_offset = 0;
159 static int file_overwrite = 0;
160 static char *str_title = NULL;
161 static char *str_author = NULL;
162 static char *str_copyright = NULL;
163 static char *str_comment = NULL;
164 static char *str_album = NULL;
165 static int do_benchmark = 0;
166 static int do_hex_dump = 0;
167 static int do_pkt_dump = 0;
168 static int do_psnr = 0;
169 static int do_pass = 0;
170 static char *pass_logfilename = NULL;
171 static int audio_stream_copy = 0;
172 static int video_stream_copy = 0;
173 static int subtitle_stream_copy = 0;
174 static int video_sync_method= 1;
175 static int audio_sync_method= 0;
176 static int copy_ts= 0;
177 static int opt_shortest = 0; //
178 static int video_global_header = 0;
179 static FILE *fvstats= NULL;
181 static int rate_emu = 0;
183 static int video_channel = 0;
184 static char *video_standard = "ntsc";
186 static int audio_volume = 256;
188 static int using_stdin = 0;
189 static int using_vhook = 0;
190 static int verbose = 1;
191 static int thread_count= 1;
192 static int q_pressed = 0;
193 static int64_t video_size = 0;
194 static int64_t audio_size = 0;
195 static int64_t extra_size = 0;
196 static int nb_frames_dup = 0;
197 static int nb_frames_drop = 0;
198 static int input_sync;
199 static uint64_t limit_filesize = 0; //
201 static int pgmyuv_compatibility_hack=0;
202 static int dts_delta_threshold = 10;
204 static int sws_flags = SWS_BICUBIC;
206 const char **opt_names=NULL;
207 int opt_name_count=0;
208 AVCodecContext *avctx_opts[CODEC_TYPE_NB];
209 AVFormatContext *avformat_opts;
210 static int64_t timer_start = 0;
212 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
213 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
214 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
216 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
218 struct AVInputStream;
220 typedef struct AVOutputStream {
221 int file_index; /* file index */
222 int index; /* stream index in the output file */
223 int source_index; /* AVInputStream index */
224 AVStream *st; /* stream in the output file */
225 int encoding_needed; /* true if encoding needed for this stream */
227 /* input pts and corresponding output pts
229 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
230 struct AVInputStream *sync_ist; /* input stream to sync against */
231 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
234 AVFrame pict_tmp; /* temporary image for resampling */
235 struct SwsContext *img_resample_ctx; /* for image resampling */
239 int topBand; /* cropping area sizes */
243 int padtop; /* padding area sizes */
250 ReSampleContext *resample; /* for audio resampling */
251 AVFifoBuffer fifo; /* for compression: one audio fifo per codec */
255 typedef struct AVInputStream {
259 int discard; /* true if stream data should be discarded */
260 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
261 int64_t sample_index; /* current sample */
263 int64_t start; /* time when read started */
264 unsigned long frame; /* current frame */
265 int64_t next_pts; /* synthetic pts for cases where pkt.pts
267 int64_t pts; /* current pts */
268 int is_start; /* is 1 at the start and after a discontinuity */
271 typedef struct AVInputFile {
272 int eof_reached; /* true if eof reached */
273 int ist_index; /* index of first stream in ist_table */
274 int buffer_size; /* current total buffer size */
275 int nb_streams; /* nb streams we are aware of */
280 /* init terminal so that we can grab keys */
281 static struct termios oldtty;
284 static void term_exit(void)
287 tcsetattr (0, TCSANOW, &oldtty);
291 static volatile sig_atomic_t received_sigterm = 0;
294 sigterm_handler(int sig)
296 received_sigterm = sig;
300 static void term_init(void)
308 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
309 |INLCR|IGNCR|ICRNL|IXON);
310 tty.c_oflag |= OPOST;
311 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
312 tty.c_cflag &= ~(CSIZE|PARENB);
317 tcsetattr (0, TCSANOW, &tty);
318 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
321 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
322 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
324 register a function to be called at normal program termination
327 #ifdef CONFIG_BEOS_NETSERVER
328 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
332 /* read a key without blocking */
333 static int read_key(void)
341 #ifndef CONFIG_BEOS_NETSERVER
349 n = select(1, &rfds, NULL, NULL, &tv);
362 static int decode_interrupt_cb(void)
364 return q_pressed || (q_pressed = read_key() == 'q');
367 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
372 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
375 /* copy stream format */
376 s->nb_streams = ic->nb_streams;
377 for(i=0;i<ic->nb_streams;i++) {
380 // FIXME: a more elegant solution is needed
381 st = av_mallocz(sizeof(AVStream));
382 memcpy(st, ic->streams[i], sizeof(AVStream));
383 st->codec = avcodec_alloc_context();
384 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
388 av_close_input_file(ic);
393 get_sync_ipts(const AVOutputStream *ost)
395 const AVInputStream *ist = ost->sync_ist;
396 return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
399 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
401 AVPacket new_pkt= *pkt;
402 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
403 &new_pkt.data, &new_pkt.size,
404 pkt->data, pkt->size,
405 pkt->flags & PKT_FLAG_KEY);
408 new_pkt.destruct= av_destruct_packet;
415 av_interleaved_write_frame(s, pkt);
418 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
420 static void do_audio_out(AVFormatContext *s,
423 unsigned char *buf, int size)
426 static uint8_t *audio_buf = NULL;
427 static uint8_t *audio_out = NULL;
428 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
430 int size_out, frame_bytes, ret;
431 AVCodecContext *enc= ost->st->codec;
433 /* SC: dynamic allocation of buffers */
435 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
437 audio_out = av_malloc(audio_out_size);
438 if (!audio_buf || !audio_out)
439 return; /* Should signal an error ! */
441 if(audio_sync_method){
442 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
443 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
444 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
445 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
447 //FIXME resample delay
448 if(fabs(delta) > 50){
451 byte_delta= FFMAX(byte_delta, -size);
455 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
460 static uint8_t *input_tmp= NULL;
461 input_tmp= av_realloc(input_tmp, byte_delta + size);
463 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
466 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
468 memset(input_tmp, 0, byte_delta);
469 memcpy(input_tmp + byte_delta, buf, size);
473 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
475 }else if(audio_sync_method>1){
476 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
477 assert(ost->audio_resample);
479 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
480 // 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));
481 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
485 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
486 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
488 if (ost->audio_resample) {
490 size_out = audio_resample(ost->resample,
491 (short *)buftmp, (short *)buf,
492 size / (ist->st->codec->channels * 2));
493 size_out = size_out * enc->channels * 2;
499 /* now encode as many frames as possible */
500 if (enc->frame_size > 1) {
501 /* output resampled raw samples */
502 av_fifo_write(&ost->fifo, buftmp, size_out);
504 frame_bytes = enc->frame_size * 2 * enc->channels;
506 while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
508 av_init_packet(&pkt);
510 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
513 pkt.stream_index= ost->index;
516 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
517 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
518 pkt.flags |= PKT_FLAG_KEY;
519 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
521 ost->sync_opts += enc->frame_size;
525 av_init_packet(&pkt);
527 ost->sync_opts += size_out / (2 * enc->channels);
529 /* output a pcm frame */
530 /* XXX: change encoding codec API to avoid this ? */
531 switch(enc->codec->id) {
532 case CODEC_ID_PCM_S32LE:
533 case CODEC_ID_PCM_S32BE:
534 case CODEC_ID_PCM_U32LE:
535 case CODEC_ID_PCM_U32BE:
536 size_out = size_out << 1;
538 case CODEC_ID_PCM_S24LE:
539 case CODEC_ID_PCM_S24BE:
540 case CODEC_ID_PCM_U24LE:
541 case CODEC_ID_PCM_U24BE:
542 case CODEC_ID_PCM_S24DAUD:
543 size_out = size_out / 2 * 3;
545 case CODEC_ID_PCM_S16LE:
546 case CODEC_ID_PCM_S16BE:
547 case CODEC_ID_PCM_U16LE:
548 case CODEC_ID_PCM_U16BE:
551 size_out = size_out >> 1;
554 ret = avcodec_encode_audio(enc, audio_out, size_out,
557 pkt.stream_index= ost->index;
560 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
561 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
562 pkt.flags |= PKT_FLAG_KEY;
563 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
567 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
571 AVPicture picture_tmp;
574 dec = ist->st->codec;
576 /* deinterlace : must be done before any resize */
577 if (do_deinterlace || using_vhook) {
580 /* create temporary picture */
581 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
582 buf = av_malloc(size);
586 picture2 = &picture_tmp;
587 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
590 if(avpicture_deinterlace(picture2, picture,
591 dec->pix_fmt, dec->width, dec->height) < 0) {
592 /* if error, do not deinterlace */
598 av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
604 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
605 1000000 * ist->pts / AV_TIME_BASE);
607 if (picture != picture2)
608 *picture = *picture2;
612 /* we begin to correct av delay at this threshold */
613 #define AV_DELAY_MAX 0.100
615 static void do_subtitle_out(AVFormatContext *s,
621 static uint8_t *subtitle_out = NULL;
622 int subtitle_out_max_size = 65536;
623 int subtitle_out_size, nb, i;
627 if (pts == AV_NOPTS_VALUE) {
628 fprintf(stderr, "Subtitle packets must have a pts\n");
632 enc = ost->st->codec;
635 subtitle_out = av_malloc(subtitle_out_max_size);
638 /* Note: DVB subtitle need one packet to draw them and one other
639 packet to clear them */
640 /* XXX: signal it in the codec context ? */
641 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
646 for(i = 0; i < nb; i++) {
647 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
648 subtitle_out_max_size, sub);
650 av_init_packet(&pkt);
651 pkt.stream_index = ost->index;
652 pkt.data = subtitle_out;
653 pkt.size = subtitle_out_size;
654 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);
655 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
656 /* XXX: the pts correction is handled here. Maybe handling
657 it in the codec would be better */
659 pkt.pts += 90 * sub->start_display_time;
661 pkt.pts += 90 * sub->end_display_time;
663 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
667 static int bit_buffer_size= 1024*256;
668 static uint8_t *bit_buffer= NULL;
670 static void do_video_out(AVFormatContext *s,
676 int nb_frames, i, ret;
677 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
678 AVFrame picture_crop_temp, picture_pad_temp;
679 AVCodecContext *enc, *dec;
681 avcodec_get_frame_defaults(&picture_crop_temp);
682 avcodec_get_frame_defaults(&picture_pad_temp);
684 enc = ost->st->codec;
685 dec = ist->st->codec;
687 /* by default, we output a single frame */
692 if(video_sync_method){
694 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
695 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
698 else if (vdelta > 1.1)
699 nb_frames = lrintf(vdelta);
700 //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);
704 fprintf(stderr, "*** drop!\n");
705 }else if (nb_frames > 1) {
706 nb_frames_dup += nb_frames;
708 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
711 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
713 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
717 if (ost->video_crop) {
718 if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
719 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
722 formatted_picture = &picture_crop_temp;
724 formatted_picture = in_picture;
727 final_picture = formatted_picture;
728 padding_src = formatted_picture;
729 resampling_dst = &ost->pict_tmp;
730 if (ost->video_pad) {
731 final_picture = &ost->pict_tmp;
732 if (ost->video_resample) {
733 if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
734 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
737 resampling_dst = &picture_pad_temp;
741 if (ost->video_resample) {
743 final_picture = &ost->pict_tmp;
744 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
745 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
748 if (ost->video_pad) {
749 av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
750 enc->height, enc->width, enc->pix_fmt,
751 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
754 /* duplicates frame if needed */
755 for(i=0;i<nb_frames;i++) {
757 av_init_packet(&pkt);
758 pkt.stream_index= ost->index;
760 if (s->oformat->flags & AVFMT_RAWPICTURE) {
761 /* raw pictures are written as AVPicture structure to
762 avoid any copies. We support temorarily the older
764 AVFrame* old_frame = enc->coded_frame;
765 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
766 pkt.data= (uint8_t *)final_picture;
767 pkt.size= sizeof(AVPicture);
768 if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
769 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
770 if(dec->coded_frame && dec->coded_frame->key_frame)
771 pkt.flags |= PKT_FLAG_KEY;
773 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
774 enc->coded_frame = old_frame;
778 big_picture= *final_picture;
779 /* better than nothing: use input picture interlaced
781 big_picture.interlaced_frame = in_picture->interlaced_frame;
782 if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
783 if(top_field_first == -1)
784 big_picture.top_field_first = in_picture->top_field_first;
786 big_picture.top_field_first = top_field_first;
789 /* handles sameq here. This is not correct because it may
790 not be a global option */
792 big_picture.quality = ist->st->quality;
794 big_picture.quality = ost->st->quality;
796 big_picture.pict_type = 0;
797 // big_picture.pts = AV_NOPTS_VALUE;
798 big_picture.pts= ost->sync_opts;
799 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
800 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
801 ret = avcodec_encode_video(enc,
802 bit_buffer, bit_buffer_size,
805 fprintf(stderr, "Video encoding failed\n");
808 //enc->frame_number = enc->real_pict_num;
810 pkt.data= bit_buffer;
812 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
813 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
814 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
815 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
816 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
818 if(enc->coded_frame && enc->coded_frame->key_frame)
819 pkt.flags |= PKT_FLAG_KEY;
820 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
822 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
823 // enc->frame_number-1, enc->real_pict_num, ret,
825 /* if two pass, output log */
826 if (ost->logfile && enc->stats_out) {
827 fprintf(ost->logfile, "%s", enc->stats_out);
836 static double psnr(double d){
837 if(d==0) return INFINITY;
838 return -10.0*log(d)/log(10.0);
841 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
847 double ti1, bitrate, avg_bitrate;
850 enc = ost->st->codec;
851 if (enc->codec_type == CODEC_TYPE_VIDEO) {
852 frame_number = ost->frame_number;
853 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
854 if (enc->flags&CODEC_FLAG_PSNR)
855 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
857 fprintf(fvstats,"f_size= %6d ", frame_size);
858 /* compute pts value */
859 ti1 = ost->sync_opts * av_q2d(enc->time_base);
863 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
864 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
865 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
866 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
867 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
871 static void print_report(AVFormatContext **output_files,
872 AVOutputStream **ost_table, int nb_ostreams,
877 AVFormatContext *oc, *os;
880 int frame_number, vid, i;
881 double bitrate, ti1, pts;
882 static int64_t last_time = -1;
883 static int qp_histogram[52];
885 if (!is_last_report) {
887 /* display the report every 0.5 seconds */
888 cur_time = av_gettime();
889 if (last_time == -1) {
890 last_time = cur_time;
893 if ((cur_time - last_time) < 500000)
895 last_time = cur_time;
899 oc = output_files[0];
901 total_size = url_fsize(&oc->pb);
902 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
903 total_size= url_ftell(&oc->pb);
908 for(i=0;i<nb_ostreams;i++) {
910 os = output_files[ost->file_index];
911 enc = ost->st->codec;
912 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
913 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
914 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
916 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
917 float t = (av_gettime()-timer_start) / 1000000.0;
919 frame_number = ost->frame_number;
920 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
921 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
922 enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
924 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
925 if(qp_hist && enc->coded_frame){
927 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
928 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
931 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
933 if (enc->flags&CODEC_FLAG_PSNR){
935 double error, error_sum=0;
936 double scale, scale_sum=0;
937 char type[3]= {'Y','U','V'};
938 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
941 error= enc->error[j];
942 scale= enc->width*enc->height*255.0*255.0*frame_number;
944 error= enc->coded_frame->error[j];
945 scale= enc->width*enc->height*255.0*255.0;
950 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
952 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
956 /* compute min output value */
957 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
958 if ((pts < ti1) && (pts > 0))
964 if (verbose || is_last_report) {
965 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
967 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
968 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
969 (double)total_size / 1024, ti1, bitrate);
972 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
973 nb_frames_dup, nb_frames_drop);
976 fprintf(stderr, "%s \r", buf);
981 if (is_last_report && verbose >= 0){
982 int64_t raw= audio_size + video_size + extra_size;
983 fprintf(stderr, "\n");
984 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
988 100.0*(total_size - raw)/raw
993 /* pkt = NULL means EOF (needed to flush decoder buffers) */
994 static int output_packet(AVInputStream *ist, int ist_index,
995 AVOutputStream **ost_table, int nb_ostreams,
1003 int data_size, got_picture;
1005 void *buffer_to_free;
1006 static unsigned int samples_size= 0;
1007 static short *samples= NULL;
1008 AVSubtitle subtitle, *subtitle_to_free;
1012 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1013 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1014 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1016 // assert(ist->pts == ist->next_pts);
1030 /* decode the packet if needed */
1031 data_buf = NULL; /* fail safe */
1033 subtitle_to_free = NULL;
1034 if (ist->decoding_needed) {
1035 switch(ist->st->codec->codec_type) {
1036 case CODEC_TYPE_AUDIO:{
1038 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE));
1039 data_size= samples_size;
1040 /* XXX: could avoid copy if PCM 16 bits with same
1041 endianness as CPU */
1042 ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1048 /* Some bug in mpeg audio decoder gives */
1049 /* data_size < 0, it seems they are overflows */
1050 if (data_size <= 0) {
1051 /* no audio frame */
1054 data_buf = (uint8_t *)samples;
1055 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1056 (ist->st->codec->sample_rate * ist->st->codec->channels);
1058 case CODEC_TYPE_VIDEO:
1059 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1060 /* XXX: allocate picture correctly */
1061 avcodec_get_frame_defaults(&picture);
1063 ret = avcodec_decode_video(ist->st->codec,
1064 &picture, &got_picture, ptr, len);
1065 ist->st->quality= picture.quality;
1069 /* no picture yet */
1070 goto discard_packet;
1072 if (ist->st->codec->time_base.num != 0) {
1073 ist->next_pts += ((int64_t)AV_TIME_BASE *
1074 ist->st->codec->time_base.num) /
1075 ist->st->codec->time_base.den;
1079 case CODEC_TYPE_SUBTITLE:
1080 ret = avcodec_decode_subtitle(ist->st->codec,
1081 &subtitle, &got_subtitle, ptr, len);
1084 if (!got_subtitle) {
1085 goto discard_packet;
1087 subtitle_to_free = &subtitle;
1094 switch(ist->st->codec->codec_type) {
1095 case CODEC_TYPE_AUDIO:
1096 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1097 (ist->st->codec->sample_rate * ist->st->codec->channels);
1099 case CODEC_TYPE_VIDEO:
1100 if (ist->st->codec->time_base.num != 0) {
1101 ist->next_pts += ((int64_t)AV_TIME_BASE *
1102 ist->st->codec->time_base.num) /
1103 ist->st->codec->time_base.den;
1113 buffer_to_free = NULL;
1114 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1115 pre_process_video_frame(ist, (AVPicture *)&picture,
1119 // preprocess audio (volume)
1120 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1121 if (audio_volume != 256) {
1124 for(i=0;i<(data_size / sizeof(short));i++) {
1125 int v = ((*volp) * audio_volume + 128) >> 8;
1126 if (v < -32768) v = -32768;
1127 if (v > 32767) v = 32767;
1133 /* frame rate emulation */
1134 if (ist->st->codec->rate_emu) {
1135 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1136 int64_t now = av_gettime() - ist->start;
1144 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1145 is the one of the next displayed one */
1146 /* XXX: add mpeg4 too ? */
1147 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1148 if (ist->st->codec->pict_type != B_TYPE) {
1150 tmp = ist->last_ip_pts;
1151 ist->last_ip_pts = ist->frac_pts.val;
1152 ist->frac_pts.val = tmp;
1156 /* if output time reached then transcode raw format,
1157 encode packets and output them */
1158 if (start_time == 0 || ist->pts >= start_time)
1159 for(i=0;i<nb_ostreams;i++) {
1163 if (ost->source_index == ist_index) {
1164 os = output_files[ost->file_index];
1167 printf("%d: got pts=%0.3f %0.3f\n", i,
1168 (double)pkt->pts / AV_TIME_BASE,
1169 ((double)ist->pts / AV_TIME_BASE) -
1170 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1172 /* set the input output pts pairs */
1173 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1175 if (ost->encoding_needed) {
1176 switch(ost->st->codec->codec_type) {
1177 case CODEC_TYPE_AUDIO:
1178 do_audio_out(os, ost, ist, data_buf, data_size);
1180 case CODEC_TYPE_VIDEO:
1181 do_video_out(os, ost, ist, &picture, &frame_size);
1182 video_size += frame_size;
1183 if (fvstats && frame_size)
1184 do_video_stats(os, ost, frame_size);
1186 case CODEC_TYPE_SUBTITLE:
1187 do_subtitle_out(os, ost, ist, &subtitle,
1194 AVFrame avframe; //FIXME/XXX remove this
1196 av_init_packet(&opkt);
1198 /* no reencoding needed : output the packet directly */
1199 /* force the input stream PTS */
1201 avcodec_get_frame_defaults(&avframe);
1202 ost->st->codec->coded_frame= &avframe;
1203 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1205 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1206 audio_size += data_size;
1207 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1208 video_size += data_size;
1212 opkt.stream_index= ost->index;
1213 if(pkt->pts != AV_NOPTS_VALUE)
1214 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);
1216 opkt.pts= AV_NOPTS_VALUE;
1220 if (pkt->dts == AV_NOPTS_VALUE)
1221 dts = ist->next_pts;
1223 dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1224 opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
1226 opkt.flags= pkt->flags;
1228 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1229 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1230 opkt.destruct= av_destruct_packet;
1232 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1233 ost->st->codec->frame_number++;
1234 ost->frame_number++;
1235 av_free_packet(&opkt);
1239 av_free(buffer_to_free);
1240 /* XXX: allocate the subtitles in the codec ? */
1241 if (subtitle_to_free) {
1242 if (subtitle_to_free->rects != NULL) {
1243 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1244 av_free(subtitle_to_free->rects[i].bitmap);
1245 av_free(subtitle_to_free->rects[i].rgba_palette);
1247 av_freep(&subtitle_to_free->rects);
1249 subtitle_to_free->num_rects = 0;
1250 subtitle_to_free = NULL;
1257 for(i=0;i<nb_ostreams;i++) {
1259 if (ost->source_index == ist_index) {
1260 AVCodecContext *enc= ost->st->codec;
1261 os = output_files[ost->file_index];
1263 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1265 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1268 if (ost->encoding_needed) {
1272 av_init_packet(&pkt);
1273 pkt.stream_index= ost->index;
1275 switch(ost->st->codec->codec_type) {
1276 case CODEC_TYPE_AUDIO:
1277 fifo_bytes = av_fifo_size(&ost->fifo);
1279 /* encode any samples remaining in fifo */
1280 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1281 int fs_tmp = enc->frame_size;
1282 enc->frame_size = fifo_bytes / (2 * enc->channels);
1283 if(av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes) == 0) {
1284 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1286 enc->frame_size = fs_tmp;
1289 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1292 pkt.flags |= PKT_FLAG_KEY;
1294 case CODEC_TYPE_VIDEO:
1295 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1297 if(enc->coded_frame && enc->coded_frame->key_frame)
1298 pkt.flags |= PKT_FLAG_KEY;
1299 if (ost->logfile && enc->stats_out) {
1300 fprintf(ost->logfile, "%s", enc->stats_out);
1309 pkt.data= bit_buffer;
1311 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1312 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1313 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1327 * The following code is the main loop of the file converter
1329 static int av_encode(AVFormatContext **output_files,
1330 int nb_output_files,
1331 AVFormatContext **input_files,
1333 AVStreamMap *stream_maps, int nb_stream_maps)
1335 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1336 AVFormatContext *is, *os;
1337 AVCodecContext *codec, *icodec;
1338 AVOutputStream *ost, **ost_table = NULL;
1339 AVInputStream *ist, **ist_table = NULL;
1340 AVInputFile *file_table;
1343 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1347 /* input stream init */
1349 for(i=0;i<nb_input_files;i++) {
1350 is = input_files[i];
1351 file_table[i].ist_index = j;
1352 file_table[i].nb_streams = is->nb_streams;
1353 j += is->nb_streams;
1357 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1361 for(i=0;i<nb_istreams;i++) {
1362 ist = av_mallocz(sizeof(AVInputStream));
1368 for(i=0;i<nb_input_files;i++) {
1369 is = input_files[i];
1370 for(k=0;k<is->nb_streams;k++) {
1371 ist = ist_table[j++];
1372 ist->st = is->streams[k];
1373 ist->file_index = i;
1375 ist->discard = 1; /* the stream is discarded by default
1378 if (ist->st->codec->rate_emu) {
1379 ist->start = av_gettime();
1385 /* output stream init */
1387 for(i=0;i<nb_output_files;i++) {
1388 os = output_files[i];
1389 if (!os->nb_streams) {
1390 fprintf(stderr, "Output file does not contain any stream\n");
1393 nb_ostreams += os->nb_streams;
1395 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1396 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1400 /* Sanity check the mapping args -- do the input files & streams exist? */
1401 for(i=0;i<nb_stream_maps;i++) {
1402 int fi = stream_maps[i].file_index;
1403 int si = stream_maps[i].stream_index;
1405 if (fi < 0 || fi > nb_input_files - 1 ||
1406 si < 0 || si > file_table[fi].nb_streams - 1) {
1407 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1410 fi = stream_maps[i].sync_file_index;
1411 si = stream_maps[i].sync_stream_index;
1412 if (fi < 0 || fi > nb_input_files - 1 ||
1413 si < 0 || si > file_table[fi].nb_streams - 1) {
1414 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1419 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1422 for(i=0;i<nb_ostreams;i++) {
1423 ost = av_mallocz(sizeof(AVOutputStream));
1430 for(k=0;k<nb_output_files;k++) {
1431 os = output_files[k];
1432 for(i=0;i<os->nb_streams;i++) {
1434 ost = ost_table[n++];
1435 ost->file_index = k;
1437 ost->st = os->streams[i];
1438 if (nb_stream_maps > 0) {
1439 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1440 stream_maps[n-1].stream_index;
1442 /* Sanity check that the stream types match */
1443 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1444 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1445 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1446 ost->file_index, ost->index);
1451 /* get corresponding input stream index : we select the first one with the right type */
1453 for(j=0;j<nb_istreams;j++) {
1456 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1457 ost->source_index = j;
1464 /* try again and reuse existing stream */
1465 for(j=0;j<nb_istreams;j++) {
1467 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1468 ost->source_index = j;
1473 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1474 ost->file_index, ost->index);
1479 ist = ist_table[ost->source_index];
1481 ost->sync_ist = (nb_stream_maps > 0) ?
1482 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1483 stream_maps[n-1].sync_stream_index] : ist;
1487 /* for each output stream, we compute the right encoding parameters */
1488 for(i=0;i<nb_ostreams;i++) {
1490 ist = ist_table[ost->source_index];
1492 codec = ost->st->codec;
1493 icodec = ist->st->codec;
1495 if (ost->st->stream_copy) {
1496 /* if stream_copy is selected, no need to decode or encode */
1497 codec->codec_id = icodec->codec_id;
1498 codec->codec_type = icodec->codec_type;
1499 if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1500 codec->bit_rate = icodec->bit_rate;
1501 codec->extradata= icodec->extradata;
1502 codec->extradata_size= icodec->extradata_size;
1503 if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1504 codec->time_base = icodec->time_base;
1506 codec->time_base = ist->st->time_base;
1507 switch(codec->codec_type) {
1508 case CODEC_TYPE_AUDIO:
1509 codec->sample_rate = icodec->sample_rate;
1510 codec->channels = icodec->channels;
1511 codec->frame_size = icodec->frame_size;
1512 codec->block_align= icodec->block_align;
1514 case CODEC_TYPE_VIDEO:
1516 fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1519 codec->pix_fmt = icodec->pix_fmt;
1520 codec->width = icodec->width;
1521 codec->height = icodec->height;
1522 codec->has_b_frames = icodec->has_b_frames;
1524 case CODEC_TYPE_SUBTITLE:
1530 switch(codec->codec_type) {
1531 case CODEC_TYPE_AUDIO:
1532 if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1535 if (codec->channels == icodec->channels &&
1536 codec->sample_rate == icodec->sample_rate) {
1537 ost->audio_resample = 0;
1539 if (codec->channels != icodec->channels &&
1540 (icodec->codec_id == CODEC_ID_AC3 ||
1541 icodec->codec_id == CODEC_ID_DTS)) {
1542 /* Special case for 5:1 AC3 and DTS input */
1543 /* and mono or stereo output */
1544 /* Request specific number of channels */
1545 icodec->channels = codec->channels;
1546 if (codec->sample_rate == icodec->sample_rate)
1547 ost->audio_resample = 0;
1549 ost->audio_resample = 1;
1552 ost->audio_resample = 1;
1555 if(audio_sync_method>1)
1556 ost->audio_resample = 1;
1558 if(ost->audio_resample){
1559 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1560 codec->sample_rate, icodec->sample_rate);
1562 printf("Can't resample. Aborting.\n");
1566 ist->decoding_needed = 1;
1567 ost->encoding_needed = 1;
1569 case CODEC_TYPE_VIDEO:
1570 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1571 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1572 ost->video_resample = ((codec->width != icodec->width -
1573 (frame_leftBand + frame_rightBand) +
1574 (frame_padleft + frame_padright)) ||
1575 (codec->height != icodec->height -
1576 (frame_topBand + frame_bottomBand) +
1577 (frame_padtop + frame_padbottom)) ||
1578 (codec->pix_fmt != icodec->pix_fmt));
1579 if (ost->video_crop) {
1580 ost->topBand = frame_topBand;
1581 ost->leftBand = frame_leftBand;
1583 if (ost->video_pad) {
1584 ost->padtop = frame_padtop;
1585 ost->padleft = frame_padleft;
1586 ost->padbottom = frame_padbottom;
1587 ost->padright = frame_padright;
1588 if (!ost->video_resample) {
1589 avcodec_get_frame_defaults(&ost->pict_tmp);
1590 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1591 codec->width, codec->height ) )
1595 if (ost->video_resample) {
1596 avcodec_get_frame_defaults(&ost->pict_tmp);
1597 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1598 codec->width, codec->height ) ) {
1599 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1602 ost->img_resample_ctx = sws_getContext(
1603 icodec->width - (frame_leftBand + frame_rightBand),
1604 icodec->height - (frame_topBand + frame_bottomBand),
1606 codec->width - (frame_padleft + frame_padright),
1607 codec->height - (frame_padtop + frame_padbottom),
1609 sws_flags, NULL, NULL, NULL);
1610 if (ost->img_resample_ctx == NULL) {
1611 fprintf(stderr, "Cannot get resampling context\n");
1614 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1616 ost->encoding_needed = 1;
1617 ist->decoding_needed = 1;
1619 case CODEC_TYPE_SUBTITLE:
1620 ost->encoding_needed = 1;
1621 ist->decoding_needed = 1;
1628 if (ost->encoding_needed &&
1629 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1630 char logfilename[1024];
1635 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1637 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1638 if (codec->flags & CODEC_FLAG_PASS1) {
1639 f = fopen(logfilename, "w");
1641 perror(logfilename);
1646 /* read the log file */
1647 f = fopen(logfilename, "r");
1649 perror(logfilename);
1652 fseek(f, 0, SEEK_END);
1654 fseek(f, 0, SEEK_SET);
1655 logbuffer = av_malloc(size + 1);
1657 fprintf(stderr, "Could not allocate log buffer\n");
1660 size = fread(logbuffer, 1, size, f);
1662 logbuffer[size] = '\0';
1663 codec->stats_in = logbuffer;
1667 if(codec->codec_type == CODEC_TYPE_VIDEO){
1668 int size= codec->width * codec->height;
1669 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1674 bit_buffer = av_malloc(bit_buffer_size);
1678 /* dump the file output parameters - cannot be done before in case
1680 for(i=0;i<nb_output_files;i++) {
1681 dump_format(output_files[i], i, output_files[i]->filename, 1);
1684 /* dump the stream mapping */
1686 fprintf(stderr, "Stream mapping:\n");
1687 for(i=0;i<nb_ostreams;i++) {
1689 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1690 ist_table[ost->source_index]->file_index,
1691 ist_table[ost->source_index]->index,
1694 if (ost->sync_ist != ist_table[ost->source_index])
1695 fprintf(stderr, " [sync #%d.%d]",
1696 ost->sync_ist->file_index,
1697 ost->sync_ist->index);
1698 fprintf(stderr, "\n");
1702 /* open each encoder */
1703 for(i=0;i<nb_ostreams;i++) {
1705 if (ost->encoding_needed) {
1707 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1709 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1710 ost->file_index, ost->index);
1713 if (avcodec_open(ost->st->codec, codec) < 0) {
1714 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1715 ost->file_index, ost->index);
1718 extra_size += ost->st->codec->extradata_size;
1722 /* open each decoder */
1723 for(i=0;i<nb_istreams;i++) {
1725 if (ist->decoding_needed) {
1727 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1729 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1730 ist->st->codec->codec_id, ist->file_index, ist->index);
1733 if (avcodec_open(ist->st->codec, codec) < 0) {
1734 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1735 ist->file_index, ist->index);
1738 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1739 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1744 for(i=0;i<nb_istreams;i++) {
1746 is = input_files[ist->file_index];
1748 ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1749 if(ist->st->start_time == AV_NOPTS_VALUE)
1751 if(input_files_ts_offset[ist->file_index])
1752 ist->next_pts= AV_NOPTS_VALUE;
1756 /* set meta data information from input file if required */
1757 for (i=0;i<nb_meta_data_maps;i++) {
1758 AVFormatContext *out_file;
1759 AVFormatContext *in_file;
1761 int out_file_index = meta_data_maps[i].out_file;
1762 int in_file_index = meta_data_maps[i].in_file;
1763 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1764 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1765 ret = AVERROR(EINVAL);
1768 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1769 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1770 ret = AVERROR(EINVAL);
1774 out_file = output_files[out_file_index];
1775 in_file = input_files[in_file_index];
1777 strcpy(out_file->title, in_file->title);
1778 strcpy(out_file->author, in_file->author);
1779 strcpy(out_file->copyright, in_file->copyright);
1780 strcpy(out_file->comment, in_file->comment);
1781 strcpy(out_file->album, in_file->album);
1782 out_file->year = in_file->year;
1783 out_file->track = in_file->track;
1784 strcpy(out_file->genre, in_file->genre);
1787 /* open files and write file headers */
1788 for(i=0;i<nb_output_files;i++) {
1789 os = output_files[i];
1790 if (av_write_header(os) < 0) {
1791 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1792 ret = AVERROR(EINVAL);
1797 if ( !using_stdin && verbose >= 0) {
1798 fprintf(stderr, "Press [q] to stop encoding\n");
1799 url_set_interrupt_cb(decode_interrupt_cb);
1804 timer_start = av_gettime();
1806 for(; received_sigterm == 0;) {
1807 int file_index, ist_index;
1815 /* if 'q' pressed, exits */
1819 /* read_key() returns 0 on EOF */
1825 /* select the stream that we must read now by looking at the
1826 smallest output pts */
1828 for(i=0;i<nb_ostreams;i++) {
1831 os = output_files[ost->file_index];
1832 ist = ist_table[ost->source_index];
1833 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1834 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1836 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1837 ipts = (double)ist->pts;
1838 if (!file_table[ist->file_index].eof_reached){
1839 if(ipts < ipts_min) {
1841 if(input_sync ) file_index = ist->file_index;
1843 if(opts < opts_min) {
1845 if(!input_sync) file_index = ist->file_index;
1848 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1853 /* if none, if is finished */
1854 if (file_index < 0) {
1858 /* finish if recording time exhausted */
1859 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1862 /* finish if limit size exhausted */
1863 if (limit_filesize != 0 && limit_filesize < url_ftell(&output_files[0]->pb))
1866 /* read a frame from it and output it in the fifo */
1867 is = input_files[file_index];
1868 if (av_read_frame(is, &pkt) < 0) {
1869 file_table[file_index].eof_reached = 1;
1870 if (opt_shortest) break; else continue; //
1874 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
1876 /* the following test is needed in case new streams appear
1877 dynamically in stream : we ignore them */
1878 if (pkt.stream_index >= file_table[file_index].nb_streams)
1879 goto discard_packet;
1880 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1881 ist = ist_table[ist_index];
1883 goto discard_packet;
1885 // 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);
1886 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1887 int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1888 if(FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1889 input_files_ts_offset[ist->file_index]-= delta;
1891 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1892 for(i=0; i<file_table[file_index].nb_streams; i++){
1893 int index= file_table[file_index].ist_index + i;
1894 ist_table[index]->next_pts += delta;
1895 ist_table[index]->is_start=1;
1900 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1901 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1904 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1905 ist->file_index, ist->index);
1907 av_free_packet(&pkt);
1912 av_free_packet(&pkt);
1914 /* dump report by using the output first video and audio streams */
1915 print_report(output_files, ost_table, nb_ostreams, 0);
1918 /* at the end of stream, we must flush the decoder buffers */
1919 for(i=0;i<nb_istreams;i++) {
1921 if (ist->decoding_needed) {
1922 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1928 /* write the trailer if needed and close file */
1929 for(i=0;i<nb_output_files;i++) {
1930 os = output_files[i];
1931 av_write_trailer(os);
1934 /* dump report by using the first video and audio streams */
1935 print_report(output_files, ost_table, nb_ostreams, 1);
1937 /* close each encoder */
1938 for(i=0;i<nb_ostreams;i++) {
1940 if (ost->encoding_needed) {
1941 av_freep(&ost->st->codec->stats_in);
1942 avcodec_close(ost->st->codec);
1946 /* close each decoder */
1947 for(i=0;i<nb_istreams;i++) {
1949 if (ist->decoding_needed) {
1950 avcodec_close(ist->st->codec);
1958 av_freep(&bit_buffer);
1959 av_free(file_table);
1962 for(i=0;i<nb_istreams;i++) {
1969 for(i=0;i<nb_ostreams;i++) {
1973 fclose(ost->logfile);
1974 ost->logfile = NULL;
1976 av_fifo_free(&ost->fifo); /* works even if fifo is not
1977 initialized but set to zero */
1978 av_free(ost->pict_tmp.data[0]);
1979 if (ost->video_resample)
1980 sws_freeContext(ost->img_resample_ctx);
1981 if (ost->audio_resample)
1982 audio_resample_close(ost->resample);
1990 ret = AVERROR(ENOMEM);
1995 int file_read(const char *filename)
1998 unsigned char buffer[1024];
2001 if (url_open(&h, filename, O_RDONLY) < 0) {
2002 printf("could not open '%s'\n", filename);
2006 len = url_read(h, buffer, sizeof(buffer));
2009 for(i=0;i<len;i++) putchar(buffer[i]);
2016 static void opt_format(const char *arg)
2018 /* compatibility stuff for pgmyuv */
2019 if (!strcmp(arg, "pgmyuv")) {
2020 pgmyuv_compatibility_hack=1;
2021 // opt_image_format(arg);
2023 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2026 file_iformat = av_find_input_format(arg);
2027 file_oformat = guess_format(arg, NULL, NULL);
2028 if (!file_iformat && !file_oformat) {
2029 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2034 static void opt_video_rc_eq(char *arg)
2039 static void opt_video_rc_override_string(char *arg)
2041 video_rc_override_string = arg;
2044 static void opt_me_threshold(const char *arg)
2046 me_threshold = atoi(arg);
2049 static void opt_verbose(const char *arg)
2051 verbose = atoi(arg);
2052 av_log_level = atoi(arg);
2055 static void opt_frame_rate(const char *arg)
2057 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2058 fprintf(stderr, "Incorrect frame rate\n");
2063 static void opt_frame_crop_top(const char *arg)
2065 frame_topBand = atoi(arg);
2066 if (frame_topBand < 0) {
2067 fprintf(stderr, "Incorrect top crop size\n");
2070 if ((frame_topBand % 2) != 0) {
2071 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2074 if ((frame_topBand) >= frame_height){
2075 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2078 frame_height -= frame_topBand;
2081 static void opt_frame_crop_bottom(const char *arg)
2083 frame_bottomBand = atoi(arg);
2084 if (frame_bottomBand < 0) {
2085 fprintf(stderr, "Incorrect bottom crop size\n");
2088 if ((frame_bottomBand % 2) != 0) {
2089 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2092 if ((frame_bottomBand) >= frame_height){
2093 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2096 frame_height -= frame_bottomBand;
2099 static void opt_frame_crop_left(const char *arg)
2101 frame_leftBand = atoi(arg);
2102 if (frame_leftBand < 0) {
2103 fprintf(stderr, "Incorrect left crop size\n");
2106 if ((frame_leftBand % 2) != 0) {
2107 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2110 if ((frame_leftBand) >= frame_width){
2111 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2114 frame_width -= frame_leftBand;
2117 static void opt_frame_crop_right(const char *arg)
2119 frame_rightBand = atoi(arg);
2120 if (frame_rightBand < 0) {
2121 fprintf(stderr, "Incorrect right crop size\n");
2124 if ((frame_rightBand % 2) != 0) {
2125 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2128 if ((frame_rightBand) >= frame_width){
2129 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2132 frame_width -= frame_rightBand;
2135 static void opt_frame_size(const char *arg)
2137 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2138 fprintf(stderr, "Incorrect frame size\n");
2141 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2142 fprintf(stderr, "Frame size must be a multiple of 2\n");
2148 #define SCALEBITS 10
2149 #define ONE_HALF (1 << (SCALEBITS - 1))
2150 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2152 #define RGB_TO_Y(r, g, b) \
2153 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2154 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2156 #define RGB_TO_U(r1, g1, b1, shift)\
2157 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2158 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2160 #define RGB_TO_V(r1, g1, b1, shift)\
2161 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2162 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2164 static void opt_pad_color(const char *arg) {
2165 /* Input is expected to be six hex digits similar to
2166 how colors are expressed in html tags (but without the #) */
2167 int rgb = strtol(arg, NULL, 16);
2171 g = ((rgb >> 8) & 255);
2174 padcolor[0] = RGB_TO_Y(r,g,b);
2175 padcolor[1] = RGB_TO_U(r,g,b,0);
2176 padcolor[2] = RGB_TO_V(r,g,b,0);
2179 static void opt_frame_pad_top(const char *arg)
2181 frame_padtop = atoi(arg);
2182 if (frame_padtop < 0) {
2183 fprintf(stderr, "Incorrect top pad size\n");
2186 if ((frame_padtop % 2) != 0) {
2187 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2192 static void opt_frame_pad_bottom(const char *arg)
2194 frame_padbottom = atoi(arg);
2195 if (frame_padbottom < 0) {
2196 fprintf(stderr, "Incorrect bottom pad size\n");
2199 if ((frame_padbottom % 2) != 0) {
2200 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2206 static void opt_frame_pad_left(const char *arg)
2208 frame_padleft = atoi(arg);
2209 if (frame_padleft < 0) {
2210 fprintf(stderr, "Incorrect left pad size\n");
2213 if ((frame_padleft % 2) != 0) {
2214 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2220 static void opt_frame_pad_right(const char *arg)
2222 frame_padright = atoi(arg);
2223 if (frame_padright < 0) {
2224 fprintf(stderr, "Incorrect right pad size\n");
2227 if ((frame_padright % 2) != 0) {
2228 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2234 static void opt_frame_pix_fmt(const char *arg)
2236 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2239 static void opt_frame_aspect_ratio(const char *arg)
2245 p = strchr(arg, ':');
2247 x = strtol(arg, (char **)&arg, 10);
2249 y = strtol(arg+1, (char **)&arg, 10);
2251 ar = (double)x / (double)y;
2253 ar = strtod(arg, (char **)&arg);
2256 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2259 frame_aspect_ratio = ar;
2262 static void opt_qscale(const char *arg)
2264 video_qscale = atof(arg);
2265 if (video_qscale <= 0 ||
2266 video_qscale > 255) {
2267 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2272 static void opt_qdiff(const char *arg)
2274 video_qdiff = atoi(arg);
2275 if (video_qdiff < 0 ||
2277 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2282 static void opt_strict(const char *arg)
2287 static void opt_top_field_first(const char *arg)
2289 top_field_first= atoi(arg);
2292 static void opt_thread_count(const char *arg)
2294 thread_count= atoi(arg);
2295 #if !defined(HAVE_THREADS)
2297 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2301 static void opt_audio_rate(const char *arg)
2303 audio_sample_rate = atoi(arg);
2306 static void opt_audio_channels(const char *arg)
2308 audio_channels = atoi(arg);
2311 static void opt_video_channel(const char *arg)
2313 video_channel = strtol(arg, NULL, 0);
2316 static void opt_video_standard(const char *arg)
2318 video_standard = av_strdup(arg);
2321 static void opt_codec(int *pstream_copy, int *pcodec_id,
2322 int codec_type, const char *arg)
2326 if (!strcmp(arg, "copy")) {
2331 if (!strcmp(p->name, arg) && p->type == codec_type)
2336 fprintf(stderr, "Unknown codec '%s'\n", arg);
2344 static void opt_audio_codec(const char *arg)
2346 opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2349 static void opt_audio_tag(const char *arg)
2352 audio_codec_tag= strtol(arg, &tail, 0);
2355 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2358 static void opt_video_tag(const char *arg)
2361 video_codec_tag= strtol(arg, &tail, 0);
2364 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2367 static void add_frame_hooker(const char *arg)
2372 char *args = av_strdup(arg);
2376 argv[0] = strtok(args, " ");
2377 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2380 i = frame_hook_add(argc, argv);
2383 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2388 const char *motion_str[] = {
2401 static void opt_motion_estimation(const char *arg)
2407 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2410 if (!strcmp(*p, arg))
2414 me_method = (p - motion_str) + 1;
2417 static void opt_video_codec(const char *arg)
2419 opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2422 static void opt_subtitle_codec(const char *arg)
2424 opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2427 static void opt_map(const char *arg)
2433 m = &stream_maps[nb_stream_maps++];
2435 m->file_index = strtol(arg, (char **)&p, 0);
2439 m->stream_index = strtol(p, (char **)&p, 0);
2442 m->sync_file_index = strtol(p, (char **)&p, 0);
2445 m->sync_stream_index = strtol(p, (char **)&p, 0);
2447 m->sync_file_index = m->file_index;
2448 m->sync_stream_index = m->stream_index;
2452 static void opt_map_meta_data(const char *arg)
2458 m = &meta_data_maps[nb_meta_data_maps++];
2460 m->out_file = strtol(arg, (char **)&p, 0);
2464 m->in_file = strtol(p, (char **)&p, 0);
2467 static void opt_recording_time(const char *arg)
2469 recording_time = parse_date(arg, 1);
2472 static void opt_start_time(const char *arg)
2474 start_time = parse_date(arg, 1);
2477 static void opt_rec_timestamp(const char *arg)
2479 rec_timestamp = parse_date(arg, 0) / 1000000;
2482 static void opt_input_ts_offset(const char *arg)
2484 input_ts_offset = parse_date(arg, 1);
2487 static void opt_input_file(const char *filename)
2489 AVFormatContext *ic;
2490 AVFormatParameters params, *ap = ¶ms;
2491 int err, i, ret, rfps, rfps_base;
2494 if (!strcmp(filename, "-"))
2497 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2498 !strcmp( filename, "/dev/stdin" );
2500 /* get default parameters from command line */
2501 ic = av_alloc_format_context();
2503 memset(ap, 0, sizeof(*ap));
2504 ap->prealloced_context = 1;
2505 ap->sample_rate = audio_sample_rate;
2506 ap->channels = audio_channels;
2507 ap->time_base.den = frame_rate;
2508 ap->time_base.num = frame_rate_base;
2509 ap->width = frame_width + frame_padleft + frame_padright;
2510 ap->height = frame_height + frame_padtop + frame_padbottom;
2511 ap->pix_fmt = frame_pix_fmt;
2512 ap->channel = video_channel;
2513 ap->standard = video_standard;
2514 ap->video_codec_id = video_codec_id;
2515 ap->audio_codec_id = audio_codec_id;
2516 if(pgmyuv_compatibility_hack)
2517 ap->video_codec_id= CODEC_ID_PGMYUV;
2519 for(i=0; i<opt_name_count; i++){
2520 const AVOption *opt;
2521 double d= av_get_double(avformat_opts, opt_names[i], &opt);
2522 if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2523 av_set_double(ic, opt_names[i], d);
2525 /* open the input file with generic libav function */
2526 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2528 print_error(filename, err);
2532 ic->loop_input = loop_input;
2534 /* If not enough info to get the stream parameters, we decode the
2535 first frames to get it. (used in mpeg case for example) */
2536 ret = av_find_stream_info(ic);
2537 if (ret < 0 && verbose >= 0) {
2538 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2542 timestamp = start_time;
2543 /* add the stream start time */
2544 if (ic->start_time != AV_NOPTS_VALUE)
2545 timestamp += ic->start_time;
2547 /* if seeking requested, we execute it */
2548 if (start_time != 0) {
2549 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2551 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2552 filename, (double)timestamp / AV_TIME_BASE);
2554 /* reset seek info */
2558 /* update the current parameters so that they match the one of the input stream */
2559 for(i=0;i<ic->nb_streams;i++) {
2561 AVCodecContext *enc = ic->streams[i]->codec;
2563 avcodec_thread_init(enc, thread_count);
2564 enc->thread_count= thread_count;
2565 switch(enc->codec_type) {
2566 case CODEC_TYPE_AUDIO:
2567 for(j=0; j<opt_name_count; j++){
2568 const AVOption *opt;
2569 double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt);
2570 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2571 av_set_double(enc, opt_names[j], d);
2573 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2574 audio_channels = enc->channels;
2575 audio_sample_rate = enc->sample_rate;
2577 ic->streams[i]->discard= AVDISCARD_ALL;
2579 case CODEC_TYPE_VIDEO:
2580 for(j=0; j<opt_name_count; j++){
2581 const AVOption *opt;
2582 double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt);
2583 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2584 av_set_double(enc, opt_names[j], d);
2586 frame_height = enc->height;
2587 frame_width = enc->width;
2588 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2589 frame_pix_fmt = enc->pix_fmt;
2590 rfps = ic->streams[i]->r_frame_rate.num;
2591 rfps_base = ic->streams[i]->r_frame_rate.den;
2592 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2594 enc->debug |= FF_DEBUG_MV;
2596 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2599 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2600 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2602 (float)rfps / rfps_base, rfps, rfps_base);
2604 /* update the current frame rate to match the stream frame rate */
2606 frame_rate_base = rfps_base;
2608 enc->rate_emu = rate_emu;
2610 ic->streams[i]->discard= AVDISCARD_ALL;
2611 else if(video_discard)
2612 ic->streams[i]->discard= video_discard;
2614 case CODEC_TYPE_DATA:
2616 case CODEC_TYPE_SUBTITLE:
2618 case CODEC_TYPE_UNKNOWN:
2625 input_files[nb_input_files] = ic;
2626 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2627 /* dump the file content */
2629 dump_format(ic, nb_input_files, filename, 0);
2632 file_iformat = NULL;
2633 file_oformat = NULL;
2640 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2642 int has_video, has_audio, i, j;
2643 AVFormatContext *ic;
2647 for(j=0;j<nb_input_files;j++) {
2648 ic = input_files[j];
2649 for(i=0;i<ic->nb_streams;i++) {
2650 AVCodecContext *enc = ic->streams[i]->codec;
2651 switch(enc->codec_type) {
2652 case CODEC_TYPE_AUDIO:
2655 case CODEC_TYPE_VIDEO:
2658 case CODEC_TYPE_DATA:
2659 case CODEC_TYPE_UNKNOWN:
2660 case CODEC_TYPE_SUBTITLE:
2667 *has_video_ptr = has_video;
2668 *has_audio_ptr = has_audio;
2671 static void new_video_stream(AVFormatContext *oc)
2674 AVCodecContext *video_enc;
2677 st = av_new_stream(oc, oc->nb_streams);
2679 fprintf(stderr, "Could not alloc stream\n");
2682 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2683 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2684 video_bitstream_filters= NULL;
2687 avcodec_thread_init(st->codec, thread_count);
2689 video_enc = st->codec;
2692 video_enc->codec_tag= video_codec_tag;
2694 if( (video_global_header&1)
2695 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2696 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2697 avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2699 if(video_global_header&2){
2700 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2701 avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2704 if (video_stream_copy) {
2705 st->stream_copy = 1;
2706 video_enc->codec_type = CODEC_TYPE_VIDEO;
2712 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2713 if (video_codec_id != CODEC_ID_NONE)
2714 codec_id = video_codec_id;
2716 video_enc->codec_id = codec_id;
2717 codec = avcodec_find_encoder(codec_id);
2719 for(i=0; i<opt_name_count; i++){
2720 const AVOption *opt;
2721 double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt);
2722 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2723 av_set_double(video_enc, opt_names[i], d);
2726 video_enc->time_base.den = frame_rate;
2727 video_enc->time_base.num = frame_rate_base;
2728 if(codec && codec->supported_framerates){
2729 const AVRational *p= codec->supported_framerates;
2730 AVRational req= (AVRational){frame_rate, frame_rate_base};
2731 const AVRational *best=NULL;
2732 AVRational best_error= (AVRational){INT_MAX, 1};
2733 for(; p->den!=0; p++){
2734 AVRational error= av_sub_q(req, *p);
2735 if(error.num <0) error.num *= -1;
2736 if(av_cmp_q(error, best_error) < 0){
2741 video_enc->time_base.den= best->num;
2742 video_enc->time_base.num= best->den;
2745 video_enc->width = frame_width + frame_padright + frame_padleft;
2746 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2747 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2748 video_enc->pix_fmt = frame_pix_fmt;
2750 if(codec && codec->pix_fmts){
2751 const enum PixelFormat *p= codec->pix_fmts;
2753 if(*p == video_enc->pix_fmt)
2757 video_enc->pix_fmt = codec->pix_fmts[0];
2761 video_enc->gop_size = 0;
2762 if (video_qscale || same_quality) {
2763 video_enc->flags |= CODEC_FLAG_QSCALE;
2764 video_enc->global_quality=
2765 st->quality = FF_QP2LAMBDA * video_qscale;
2769 video_enc->intra_matrix = intra_matrix;
2771 video_enc->inter_matrix = inter_matrix;
2773 video_enc->max_qdiff = video_qdiff;
2774 video_enc->rc_eq = video_rc_eq;
2775 video_enc->thread_count = thread_count;
2776 p= video_rc_override_string;
2779 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2781 fprintf(stderr, "error parsing rc_override\n");
2784 video_enc->rc_override=
2785 av_realloc(video_enc->rc_override,
2786 sizeof(RcOverride)*(i+1));
2787 video_enc->rc_override[i].start_frame= start;
2788 video_enc->rc_override[i].end_frame = end;
2790 video_enc->rc_override[i].qscale= q;
2791 video_enc->rc_override[i].quality_factor= 1.0;
2794 video_enc->rc_override[i].qscale= 0;
2795 video_enc->rc_override[i].quality_factor= -q/100.0;
2800 video_enc->rc_override_count=i;
2801 if (!video_enc->rc_initial_buffer_occupancy)
2802 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2803 video_enc->me_threshold= me_threshold;
2804 video_enc->intra_dc_precision= intra_dc_precision - 8;
2805 video_enc->strict_std_compliance = strict;
2808 video_enc->flags|= CODEC_FLAG_PSNR;
2810 video_enc->me_method = me_method;
2815 video_enc->flags |= CODEC_FLAG_PASS1;
2817 video_enc->flags |= CODEC_FLAG_PASS2;
2822 /* reset some key parameters */
2824 video_codec_id = CODEC_ID_NONE;
2825 video_stream_copy = 0;
2828 static void new_audio_stream(AVFormatContext *oc)
2831 AVCodecContext *audio_enc;
2834 st = av_new_stream(oc, oc->nb_streams);
2836 fprintf(stderr, "Could not alloc stream\n");
2839 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
2841 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2842 audio_bitstream_filters= NULL;
2845 avcodec_thread_init(st->codec, thread_count);
2847 audio_enc = st->codec;
2848 audio_enc->codec_type = CODEC_TYPE_AUDIO;
2849 audio_enc->strict_std_compliance = strict;
2852 audio_enc->codec_tag= audio_codec_tag;
2854 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2855 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2856 avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2858 if (audio_stream_copy) {
2859 st->stream_copy = 1;
2860 audio_enc->channels = audio_channels;
2862 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2864 for(i=0; i<opt_name_count; i++){
2865 const AVOption *opt;
2866 double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt);
2867 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2868 av_set_double(audio_enc, opt_names[i], d);
2871 if (audio_codec_id != CODEC_ID_NONE)
2872 codec_id = audio_codec_id;
2873 audio_enc->codec_id = codec_id;
2875 if (audio_qscale > QSCALE_NONE) {
2876 audio_enc->flags |= CODEC_FLAG_QSCALE;
2877 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
2879 audio_enc->thread_count = thread_count;
2880 audio_enc->channels = audio_channels;
2882 audio_enc->sample_rate = audio_sample_rate;
2883 audio_enc->time_base= (AVRational){1, audio_sample_rate};
2884 if (audio_language) {
2885 pstrcpy(st->language, sizeof(st->language), audio_language);
2886 av_free(audio_language);
2887 audio_language = NULL;
2890 /* reset some key parameters */
2892 audio_codec_id = CODEC_ID_NONE;
2893 audio_stream_copy = 0;
2896 static void opt_new_subtitle_stream(void)
2898 AVFormatContext *oc;
2900 AVCodecContext *subtitle_enc;
2903 if (nb_output_files <= 0) {
2904 fprintf(stderr, "At least one output file must be specified\n");
2907 oc = output_files[nb_output_files - 1];
2909 st = av_new_stream(oc, oc->nb_streams);
2911 fprintf(stderr, "Could not alloc stream\n");
2914 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
2916 subtitle_enc = st->codec;
2917 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
2918 if (subtitle_stream_copy) {
2919 st->stream_copy = 1;
2921 for(i=0; i<opt_name_count; i++){
2922 const AVOption *opt;
2923 double d= av_get_double(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt);
2924 if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2925 av_set_double(subtitle_enc, opt_names[i], d);
2927 subtitle_enc->codec_id = subtitle_codec_id;
2930 if (subtitle_language) {
2931 pstrcpy(st->language, sizeof(st->language), subtitle_language);
2932 av_free(subtitle_language);
2933 subtitle_language = NULL;
2936 subtitle_codec_id = CODEC_ID_NONE;
2937 subtitle_stream_copy = 0;
2940 static void opt_new_audio_stream(void)
2942 AVFormatContext *oc;
2943 if (nb_output_files <= 0) {
2944 fprintf(stderr, "At least one output file must be specified\n");
2947 oc = output_files[nb_output_files - 1];
2948 new_audio_stream(oc);
2951 static void opt_new_video_stream(void)
2953 AVFormatContext *oc;
2954 if (nb_output_files <= 0) {
2955 fprintf(stderr, "At least one output file must be specified\n");
2958 oc = output_files[nb_output_files - 1];
2959 new_video_stream(oc);
2962 static void opt_output_file(const char *filename)
2964 AVFormatContext *oc;
2965 int use_video, use_audio, input_has_video, input_has_audio, i;
2966 AVFormatParameters params, *ap = ¶ms;
2968 if (!strcmp(filename, "-"))
2971 oc = av_alloc_format_context();
2973 if (!file_oformat) {
2974 file_oformat = guess_format(NULL, filename, NULL);
2975 if (!file_oformat) {
2976 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
2982 oc->oformat = file_oformat;
2983 pstrcpy(oc->filename, sizeof(oc->filename), filename);
2985 if (!strcmp(file_oformat->name, "ffm") &&
2986 strstart(filename, "http:", NULL)) {
2987 /* special case for files sent to ffserver: we get the stream
2988 parameters from ffserver */
2989 if (read_ffserver_streams(oc, filename) < 0) {
2990 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
2994 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
2995 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
2997 /* disable if no corresponding type found and at least one
2999 if (nb_input_files > 0) {
3000 check_audio_video_inputs(&input_has_video, &input_has_audio);
3001 if (!input_has_video)
3003 if (!input_has_audio)
3007 /* manual disable */
3008 if (audio_disable) {
3011 if (video_disable) {
3016 new_video_stream(oc);
3020 new_audio_stream(oc);
3023 oc->timestamp = rec_timestamp;
3026 pstrcpy(oc->title, sizeof(oc->title), str_title);
3028 pstrcpy(oc->author, sizeof(oc->author), str_author);
3030 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3032 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3034 pstrcpy(oc->album, sizeof(oc->album), str_album);
3037 output_files[nb_output_files++] = oc;
3039 /* check filename in case of an image number is expected */
3040 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3041 if (!av_filename_number_test(oc->filename)) {
3042 print_error(oc->filename, AVERROR_NUMEXPECTED);
3047 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3048 /* test if it already exists to avoid loosing precious files */
3049 if (!file_overwrite &&
3050 (strchr(filename, ':') == NULL ||
3051 strstart(filename, "file:", NULL))) {
3052 if (url_exist(filename)) {
3055 if ( !using_stdin ) {
3056 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3059 if (toupper(c) != 'Y') {
3060 fprintf(stderr, "Not overwriting - exiting\n");
3065 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3072 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3073 fprintf(stderr, "Could not open '%s'\n", filename);
3078 memset(ap, 0, sizeof(*ap));
3079 if (av_set_parameters(oc, ap) < 0) {
3080 fprintf(stderr, "%s: Invalid encoding parameters\n",
3085 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3086 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3087 oc->loop_output = loop_output;
3089 for(i=0; i<opt_name_count; i++){
3090 const AVOption *opt;
3091 double d = av_get_double(avformat_opts, opt_names[i], &opt);
3092 if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3093 av_set_double(oc, opt_names[i], d);
3096 /* reset some options */
3097 file_oformat = NULL;
3098 file_iformat = NULL;
3101 /* same option as mencoder */
3102 static void opt_pass(const char *pass_str)
3105 pass = atoi(pass_str);
3106 if (pass != 1 && pass != 2) {
3107 fprintf(stderr, "pass number can be only 1 or 2\n");
3113 #if defined(__MINGW32__) || defined(CONFIG_OS2)
3114 static int64_t getutime(void)
3116 return av_gettime();
3119 static int64_t getutime(void)
3121 struct rusage rusage;
3123 getrusage(RUSAGE_SELF, &rusage);
3124 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3128 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3129 extern int ffm_nopts;
3132 static void show_formats(void)
3134 AVInputFormat *ifmt;
3135 AVOutputFormat *ofmt;
3138 const char **pp, *last_name;
3140 printf("File formats:\n");
3145 const char *name=NULL;
3146 const char *long_name=NULL;
3148 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3149 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3150 strcmp(ofmt->name, last_name)>0){
3152 long_name= ofmt->long_name;
3156 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3157 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3158 strcmp(ifmt->name, last_name)>0){
3160 long_name= ifmt->long_name;
3163 if(name && strcmp(ifmt->name, name)==0)
3175 long_name ? long_name:" ");
3179 printf("Codecs:\n");
3185 const char *type_str;
3188 for(p = first_avcodec; p != NULL; p = p->next) {
3189 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3190 strcmp(p->name, last_name)>0){
3192 decode= encode= cap=0;
3194 if(p2 && strcmp(p->name, p2->name)==0){
3195 if(p->decode) decode=1;
3196 if(p->encode) encode=1;
3197 cap |= p->capabilities;
3202 last_name= p2->name;
3205 case CODEC_TYPE_VIDEO:
3208 case CODEC_TYPE_AUDIO:
3211 case CODEC_TYPE_SUBTITLE:
3220 decode ? "D": (/*p2->decoder ? "d":*/" "),
3223 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3224 cap & CODEC_CAP_DR1 ? "D":" ",
3225 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3227 /* if(p2->decoder && decode==0)
3228 printf(" use %s for decoding", p2->decoder->name);*/
3233 printf("Supported file protocols:\n");
3234 for(up = first_protocol; up != NULL; up = up->next)
3235 printf(" %s:", up->name);
3238 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3239 printf("Motion estimation methods:\n");
3243 if ((pp - motion_str + 1) == ME_ZERO)
3244 printf("(fastest)");
3245 else if ((pp - motion_str + 1) == ME_FULL)
3246 printf("(slowest)");
3247 else if ((pp - motion_str + 1) == ME_EPZS)
3248 printf("(default)");
3253 "Note, the names of encoders and decoders dont always match, so there are\n"
3254 "several cases where the above table shows encoder only or decoder only entries\n"
3255 "even though both encoding and decoding are supported for example, the h263\n"
3256 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3261 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3264 const char *p = str;
3271 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3278 static void opt_inter_matrix(const char *arg)
3280 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3281 parse_matrix_coeffs(inter_matrix, arg);
3284 static void opt_intra_matrix(const char *arg)
3286 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3287 parse_matrix_coeffs(intra_matrix, arg);
3290 static void opt_target(const char *arg)
3293 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3295 if(!strncmp(arg, "pal-", 4)) {
3298 } else if(!strncmp(arg, "ntsc-", 5)) {
3301 } else if(!strncmp(arg, "film-", 5)) {
3306 /* Calculate FR via float to avoid int overflow */
3307 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3310 } else if((fr == 29970) || (fr == 23976)) {
3313 /* Try to determine PAL/NTSC by peeking in the input files */
3314 if(nb_input_files) {
3316 for(j = 0; j < nb_input_files; j++) {
3317 for(i = 0; i < input_files[j]->nb_streams; i++) {
3318 AVCodecContext *c = input_files[j]->streams[i]->codec;
3319 if(c->codec_type != CODEC_TYPE_VIDEO)
3321 fr = c->time_base.den * 1000 / c->time_base.num;
3325 } else if((fr == 29970) || (fr == 23976)) {
3335 if(verbose && norm >= 0)
3336 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3340 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3341 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3342 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3346 if(!strcmp(arg, "vcd")) {
3348 opt_video_codec("mpeg1video");
3349 opt_audio_codec("mp2");
3352 opt_frame_size(norm ? "352x240" : "352x288");
3353 opt_frame_rate(frame_rates[norm]);
3354 opt_default("gop", norm ? "18" : "15");
3356 opt_default("b", "1150000");
3357 opt_default("maxrate", "1150000");
3358 opt_default("minrate", "1150000");
3359 opt_default("bufsize", "327680"); // 40*1024*8;
3361 opt_default("ab", "224000");
3362 audio_sample_rate = 44100;
3365 opt_default("packetsize", "2324");
3366 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3368 /* We have to offset the PTS, so that it is consistent with the SCR.
3369 SCR starts at 36000, but the first two packs contain only padding
3370 and the first pack from the other stream, respectively, may also have
3371 been written before.
3372 So the real data starts at SCR 36000+3*1200. */
3373 mux_preload= (36000+3*1200) / 90000.0; //0.44
3374 } else if(!strcmp(arg, "svcd")) {
3376 opt_video_codec("mpeg2video");
3377 opt_audio_codec("mp2");
3380 opt_frame_size(norm ? "480x480" : "480x576");
3381 opt_frame_rate(frame_rates[norm]);
3382 opt_default("gop", norm ? "18" : "15");
3384 opt_default("b", "2040000");
3385 opt_default("maxrate", "2516000");
3386 opt_default("minrate", "0"); //1145000;
3387 opt_default("bufsize", "1835008"); //224*1024*8;
3388 opt_default("flags", "+SCAN_OFFSET");
3391 opt_default("ab", "224000");
3392 audio_sample_rate = 44100;
3394 opt_default("packetsize", "2324");
3396 } else if(!strcmp(arg, "dvd")) {
3398 opt_video_codec("mpeg2video");
3399 opt_audio_codec("ac3");
3402 opt_frame_size(norm ? "720x480" : "720x576");
3403 opt_frame_rate(frame_rates[norm]);
3404 opt_default("gop", norm ? "18" : "15");
3406 opt_default("b", "6000000");
3407 opt_default("maxrate", "9000000");
3408 opt_default("minrate", "0"); //1500000;
3409 opt_default("bufsize", "1835008"); //224*1024*8;
3411 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3412 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3414 opt_default("ab", "448000");
3415 audio_sample_rate = 48000;
3417 } else if(!strncmp(arg, "dv", 2)) {
3421 opt_frame_size(norm ? "720x480" : "720x576");
3422 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3423 (norm ? "yuv411p" : "yuv420p"));
3424 opt_frame_rate(frame_rates[norm]);
3426 audio_sample_rate = 48000;
3430 fprintf(stderr, "Unknown target: %s\n", arg);
3435 static void opt_vstats_file (const char *arg)
3439 fvstats = fopen(arg ,"w");
3447 static void opt_vstats (void)
3451 time_t today2 = time(NULL);
3452 struct tm *today = localtime(&today2);
3454 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
3457 opt_vstats_file(filename);
3461 static void opt_video_bsf(const char *arg)
3463 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3464 AVBitStreamFilterContext **bsfp;
3467 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3471 bsfp= &video_bitstream_filters;
3473 bsfp= &(*bsfp)->next;
3478 //FIXME avoid audio - video code duplication
3479 static void opt_audio_bsf(const char *arg)
3481 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3482 AVBitStreamFilterContext **bsfp;
3485 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3489 bsfp= &audio_bitstream_filters;
3491 bsfp= &(*bsfp)->next;
3496 static void show_version(void)
3498 /* TODO: add function interface to avutil and avformat */
3499 fprintf(stderr, "ffmpeg " FFMPEG_VERSION "\n"
3503 LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3507 static int opt_default(const char *opt, const char *arg){
3509 const AVOption *o= NULL;
3510 int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
3512 for(type=0; type<CODEC_TYPE_NB; type++){
3513 const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
3515 o = av_set_string(avctx_opts[type], opt, arg);
3518 o = av_set_string(avformat_opts, opt, arg);
3521 o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
3522 else if(opt[0] == 'v')
3523 o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
3524 else if(opt[0] == 's')
3525 o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
3530 // 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));
3532 //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3533 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3534 opt_names[opt_name_count++]= o->name;
3536 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3537 /* disable generate of real time pts in ffm (need to be supressed anyway) */
3538 if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)
3542 if(avctx_opts[0]->debug)
3543 av_log_level = AV_LOG_DEBUG;
3547 const OptionDef options[] = {
3549 { "L", 0, {(void*)show_license}, "show license" },
3550 { "h", 0, {(void*)show_help}, "show help" },
3551 { "version", 0, {(void*)show_version}, "show version" },
3552 { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3553 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3554 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3555 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3556 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3557 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3558 { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3559 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3560 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3561 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3562 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3563 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3564 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3565 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3566 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3567 { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3568 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3569 "add timings for benchmarking" },
3570 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3571 "dump each input packet" },
3572 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3573 "when dumping packets, also dump the payload" },
3574 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3575 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3576 { "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)", "" },
3577 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3578 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3579 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3580 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3581 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3582 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3583 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3584 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3585 { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3588 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3589 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3590 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3591 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3592 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3593 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3594 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3595 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3596 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3597 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3598 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3599 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3600 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3601 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3602 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3603 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3604 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3605 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3606 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3607 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
3608 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3609 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3610 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3611 { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3613 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
3614 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3615 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3616 "use same video quality as source (implies VBR)" },
3617 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3618 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3619 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3620 "deinterlace pictures" },
3621 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3622 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3623 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3624 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3625 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3626 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3627 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3628 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3629 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3630 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3631 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3634 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3635 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3636 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3637 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3638 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3639 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3640 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3641 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3642 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3643 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3645 /* subtitle options */
3646 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3647 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3648 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3651 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3652 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3653 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3656 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3657 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3659 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
3660 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
3662 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3666 static void show_banner(void)
3668 fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2007 Fabrice Bellard, et al.\n");
3669 fprintf(stderr, " configuration: " FFMPEG_CONFIGURATION "\n");
3670 fprintf(stderr, " libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
3671 fprintf(stderr, " libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
3672 fprintf(stderr, " libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
3673 fprintf(stderr, " built on " __DATE__ " " __TIME__);
3675 fprintf(stderr, ", gcc: " __VERSION__ "\n");
3677 fprintf(stderr, ", using a non-gcc compiler\n");
3681 static void show_license(void)
3686 "FFmpeg is free software; you can redistribute it and/or modify\n"
3687 "it under the terms of the GNU General Public License as published by\n"
3688 "the Free Software Foundation; either version 2 of the License, or\n"
3689 "(at your option) any later version.\n"
3691 "FFmpeg is distributed in the hope that it will be useful,\n"
3692 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3693 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
3694 "GNU General Public License for more details.\n"
3696 "You should have received a copy of the GNU General Public License\n"
3697 "along with FFmpeg; if not, write to the Free Software\n"
3698 "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
3702 "FFmpeg is free software; you can redistribute it and/or\n"
3703 "modify it under the terms of the GNU Lesser General Public\n"
3704 "License as published by the Free Software Foundation; either\n"
3705 "version 2.1 of the License, or (at your option) any later version.\n"
3707 "FFmpeg is distributed in the hope that it will be useful,\n"
3708 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3709 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
3710 "Lesser General Public License for more details.\n"
3712 "You should have received a copy of the GNU Lesser General Public\n"
3713 "License along with FFmpeg; if not, write to the Free Software\n"
3714 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
3720 static void show_help(void)
3723 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3724 "Hyper fast Audio and Video encoder\n");
3726 show_help_options(options, "Main options:\n",
3727 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3728 show_help_options(options, "\nVideo options:\n",
3729 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3731 show_help_options(options, "\nAdvanced Video options:\n",
3732 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3733 OPT_VIDEO | OPT_EXPERT);
3734 show_help_options(options, "\nAudio options:\n",
3735 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3737 show_help_options(options, "\nAdvanced Audio options:\n",
3738 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3739 OPT_AUDIO | OPT_EXPERT);
3740 show_help_options(options, "\nSubtitle options:\n",
3741 OPT_SUBTITLE | OPT_GRAB,
3743 show_help_options(options, "\nAudio/Video grab options:\n",
3746 show_help_options(options, "\nAdvanced options:\n",
3747 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3749 av_opt_show(avctx_opts[0], NULL);
3750 av_opt_show(avformat_opts, NULL);
3755 void parse_arg_file(const char *filename)
3757 opt_output_file(filename);
3760 int main(int argc, char **argv)
3767 for(i=0; i<CODEC_TYPE_NB; i++){
3768 avctx_opts[i]= avcodec_alloc_context2(i);
3770 avformat_opts = av_alloc_format_context();
3778 parse_options(argc, argv, options);
3780 /* file converter / grab */
3781 if (nb_output_files <= 0) {
3782 fprintf(stderr, "Must supply at least one output file\n");
3786 if (nb_input_files == 0) {
3787 fprintf(stderr, "Must supply at least one input file\n");
3792 av_encode(output_files, nb_output_files, input_files, nb_input_files,
3793 stream_maps, nb_stream_maps);
3794 ti = getutime() - ti;
3796 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3800 for(i=0;i<nb_output_files;i++) {
3801 /* maybe av_close_output_file ??? */
3802 AVFormatContext *s = output_files[i];
3804 if (!(s->oformat->flags & AVFMT_NOFILE))
3806 for(j=0;j<s->nb_streams;j++) {
3807 av_free(s->streams[j]->codec);
3808 av_free(s->streams[j]);
3812 for(i=0;i<nb_input_files;i++)
3813 av_close_input_file(input_files[i]);
3817 av_free(intra_matrix);
3818 av_free(inter_matrix);
3822 av_free(vstats_filename);
3826 #ifdef CONFIG_POWERPC_PERF
3827 extern void powerpc_display_perf_report(void);
3828 powerpc_display_perf_report();
3829 #endif /* CONFIG_POWERPC_PERF */
3831 if (received_sigterm) {
3833 "Received signal %d: terminating.\n",
3834 (int) received_sigterm);
3838 exit(0); /* not all OS-es handle main() return value */