3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 #define HAVE_AV_CONFIG_H
26 #include "framehook.h"
36 #include <sys/ioctl.h>
39 #include <sys/resource.h>
42 #include <sys/types.h>
43 #include <sys/select.h>
46 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
55 #if !defined(INFINITY) && defined(HUGE_VAL)
56 #define INFINITY HUGE_VAL
59 /* select an input stream for an output stream */
60 typedef struct AVStreamMap {
64 int sync_stream_index;
67 /** select an input file for an output file */
68 typedef struct AVMetaDataMap {
73 extern const OptionDef options[];
75 static void show_help(void);
76 static void show_license(void);
77 static int opt_default(const char *opt, const char *arg);
81 static AVFormatContext *input_files[MAX_FILES];
82 static int64_t input_files_ts_offset[MAX_FILES];
83 static int nb_input_files = 0;
85 static AVFormatContext *output_files[MAX_FILES];
86 static int nb_output_files = 0;
88 static AVStreamMap stream_maps[MAX_FILES];
89 static int nb_stream_maps;
91 static AVMetaDataMap meta_data_maps[MAX_FILES];
92 static int nb_meta_data_maps;
94 static AVInputFormat *file_iformat;
95 static AVOutputFormat *file_oformat;
96 static int frame_width = 0;
97 static int frame_height = 0;
98 static float frame_aspect_ratio = 0;
99 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
100 static int frame_padtop = 0;
101 static int frame_padbottom = 0;
102 static int frame_padleft = 0;
103 static int frame_padright = 0;
104 static int padcolor[3] = {16,128,128}; /* default to black */
105 static int frame_topBand = 0;
106 static int frame_bottomBand = 0;
107 static int frame_leftBand = 0;
108 static int frame_rightBand = 0;
109 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
110 static int frame_rate = 25;
111 static int frame_rate_base = 1;
112 static float video_qscale = 0;
113 static int video_qdiff = 3;
114 static uint16_t *intra_matrix = NULL;
115 static uint16_t *inter_matrix = NULL;
116 #if 0 //experimental, (can be removed)
117 static float video_rc_qsquish=1.0;
118 static float video_rc_qmod_amp=0;
119 static int video_rc_qmod_freq=0;
121 static char *video_rc_override_string=NULL;
122 static char *video_rc_eq="tex^qComp";
123 static int me_method = ME_EPZS;
124 static int video_disable = 0;
125 static int video_discard = 0;
126 static int video_codec_id = CODEC_ID_NONE;
127 static int video_codec_tag = 0;
128 static int same_quality = 0;
129 static int do_deinterlace = 0;
130 static int strict = 0;
131 static int top_field_first = -1;
132 static int me_threshold = 0;
133 static int intra_dc_precision = 8;
134 static int loop_input = 0;
135 static int loop_output = AVFMT_NOOUTPUTLOOP;
136 static int qp_hist = 0;
138 static int intra_only = 0;
139 static int audio_sample_rate = 44100;
140 #define QSCALE_NONE -99999
141 static float audio_qscale = QSCALE_NONE;
142 static int audio_disable = 0;
143 static int audio_channels = 1;
144 static int audio_codec_id = CODEC_ID_NONE;
145 static int audio_codec_tag = 0;
146 static char *audio_language = NULL;
148 static int subtitle_codec_id = CODEC_ID_NONE;
149 static char *subtitle_language = NULL;
151 static float mux_preload= 0.5;
152 static float mux_max_delay= 0.7;
154 static int64_t recording_time = 0;
155 static int64_t start_time = 0;
156 static int64_t rec_timestamp = 0;
157 static int64_t input_ts_offset = 0;
158 static int file_overwrite = 0;
159 static char *str_title = NULL;
160 static char *str_author = NULL;
161 static char *str_copyright = NULL;
162 static char *str_comment = NULL;
163 static char *str_album = NULL;
164 static int do_benchmark = 0;
165 static int do_hex_dump = 0;
166 static int do_pkt_dump = 0;
167 static int do_psnr = 0;
168 static int do_vstats = 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;
180 static int rate_emu = 0;
182 static int video_channel = 0;
183 static char *video_standard = "ntsc";
185 static int audio_volume = 256;
187 static int using_stdin = 0;
188 static int using_vhook = 0;
189 static int verbose = 1;
190 static int thread_count= 1;
191 static int q_pressed = 0;
192 static int64_t video_size = 0;
193 static int64_t audio_size = 0;
194 static int64_t extra_size = 0;
195 static int nb_frames_dup = 0;
196 static int nb_frames_drop = 0;
197 static int input_sync;
198 static int limit_filesize = 0; //
200 static int pgmyuv_compatibility_hack=0;
201 static int dts_delta_threshold = 10;
203 static int sws_flags = SWS_BICUBIC;
205 const char **opt_names=NULL;
206 int opt_name_count=0;
207 AVCodecContext *avctx_opts[CODEC_TYPE_NB];
208 AVFormatContext *avformat_opts;
210 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
211 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
212 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
214 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
216 struct AVInputStream;
218 typedef struct AVOutputStream {
219 int file_index; /* file index */
220 int index; /* stream index in the output file */
221 int source_index; /* AVInputStream index */
222 AVStream *st; /* stream in the output file */
223 int encoding_needed; /* true if encoding needed for this stream */
225 /* input pts and corresponding output pts
227 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
228 struct AVInputStream *sync_ist; /* input stream to sync against */
229 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
232 AVFrame pict_tmp; /* temporary image for resampling */
233 struct SwsContext *img_resample_ctx; /* for image resampling */
237 int topBand; /* cropping area sizes */
241 int padtop; /* padding area sizes */
248 ReSampleContext *resample; /* for audio resampling */
249 AVFifoBuffer fifo; /* for compression: one audio fifo per codec */
253 typedef struct AVInputStream {
257 int discard; /* true if stream data should be discarded */
258 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
259 int64_t sample_index; /* current sample */
261 int64_t start; /* time when read started */
262 unsigned long frame; /* current frame */
263 int64_t next_pts; /* synthetic pts for cases where pkt.pts
265 int64_t pts; /* current pts */
266 int is_start; /* is 1 at the start and after a discontinuity */
269 typedef struct AVInputFile {
270 int eof_reached; /* true if eof reached */
271 int ist_index; /* index of first stream in ist_table */
272 int buffer_size; /* current total buffer size */
273 int buffer_size_max; /* buffer size at which we consider we can stop
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);
606 if (picture != picture2)
607 *picture = *picture2;
611 /* we begin to correct av delay at this threshold */
612 #define AV_DELAY_MAX 0.100
614 static void do_subtitle_out(AVFormatContext *s,
620 static uint8_t *subtitle_out = NULL;
621 int subtitle_out_max_size = 65536;
622 int subtitle_out_size, nb, i;
626 if (pts == AV_NOPTS_VALUE) {
627 fprintf(stderr, "Subtitle packets must have a pts\n");
631 enc = ost->st->codec;
634 subtitle_out = av_malloc(subtitle_out_max_size);
637 /* Note: DVB subtitle need one packet to draw them and one other
638 packet to clear them */
639 /* XXX: signal it in the codec context ? */
640 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
645 for(i = 0; i < nb; i++) {
646 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
647 subtitle_out_max_size, sub);
649 av_init_packet(&pkt);
650 pkt.stream_index = ost->index;
651 pkt.data = subtitle_out;
652 pkt.size = subtitle_out_size;
653 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);
654 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
655 /* XXX: the pts correction is handled here. Maybe handling
656 it in the codec would be better */
658 pkt.pts += 90 * sub->start_display_time;
660 pkt.pts += 90 * sub->end_display_time;
662 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
666 static int bit_buffer_size= 1024*256;
667 static uint8_t *bit_buffer= NULL;
669 static void do_video_out(AVFormatContext *s,
675 int nb_frames, i, ret;
676 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
677 AVFrame picture_crop_temp, picture_pad_temp;
678 uint8_t *buf = NULL, *buf1 = NULL;
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);
839 static double psnr(double d){
840 if(d==0) return INFINITY;
841 return -10.0*log(d)/log(10.0);
844 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
847 static FILE *fvstats=NULL;
854 double ti1, bitrate, avg_bitrate;
858 today = localtime(&today2);
859 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
862 fvstats = fopen(filename,"w");
870 enc = ost->st->codec;
871 if (enc->codec_type == CODEC_TYPE_VIDEO) {
872 frame_number = ost->frame_number;
873 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
874 if (enc->flags&CODEC_FLAG_PSNR)
875 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
877 fprintf(fvstats,"f_size= %6d ", frame_size);
878 /* compute pts value */
879 ti1 = ost->sync_opts * av_q2d(enc->time_base);
883 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
884 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
885 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
886 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
887 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
891 static void print_report(AVFormatContext **output_files,
892 AVOutputStream **ost_table, int nb_ostreams,
897 AVFormatContext *oc, *os;
900 int frame_number, vid, i;
901 double bitrate, ti1, pts;
902 static int64_t last_time = -1;
903 static int qp_histogram[52];
905 if (!is_last_report) {
907 /* display the report every 0.5 seconds */
908 cur_time = av_gettime();
909 if (last_time == -1) {
910 last_time = cur_time;
913 if ((cur_time - last_time) < 500000)
915 last_time = cur_time;
919 oc = output_files[0];
921 total_size = url_ftell(&oc->pb);
926 for(i=0;i<nb_ostreams;i++) {
928 os = output_files[ost->file_index];
929 enc = ost->st->codec;
930 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
931 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
932 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
934 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
935 frame_number = ost->frame_number;
936 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%3.1f ",
937 frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
939 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
940 if(qp_hist && enc->coded_frame){
942 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
943 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
946 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
948 if (enc->flags&CODEC_FLAG_PSNR){
950 double error, error_sum=0;
951 double scale, scale_sum=0;
952 char type[3]= {'Y','U','V'};
953 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
956 error= enc->error[j];
957 scale= enc->width*enc->height*255.0*255.0*frame_number;
959 error= enc->coded_frame->error[j];
960 scale= enc->width*enc->height*255.0*255.0;
965 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
967 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
971 /* compute min output value */
972 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
973 if ((pts < ti1) && (pts > 0))
979 if (verbose || is_last_report) {
980 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
982 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
983 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
984 (double)total_size / 1024, ti1, bitrate);
987 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
988 nb_frames_dup, nb_frames_drop);
991 fprintf(stderr, "%s \r", buf);
996 if (is_last_report && verbose >= 0){
997 int64_t raw= audio_size + video_size + extra_size;
998 fprintf(stderr, "\n");
999 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1003 100.0*(total_size - raw)/raw
1008 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1009 static int output_packet(AVInputStream *ist, int ist_index,
1010 AVOutputStream **ost_table, int nb_ostreams,
1011 const AVPacket *pkt)
1013 AVFormatContext *os;
1014 AVOutputStream *ost;
1018 int data_size, got_picture;
1020 void *buffer_to_free;
1021 static unsigned int samples_size= 0;
1022 static short *samples= NULL;
1023 AVSubtitle subtitle, *subtitle_to_free;
1027 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1028 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1029 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1031 // assert(ist->pts == ist->next_pts);
1045 /* decode the packet if needed */
1046 data_buf = NULL; /* fail safe */
1048 subtitle_to_free = NULL;
1049 if (ist->decoding_needed) {
1050 switch(ist->st->codec->codec_type) {
1051 case CODEC_TYPE_AUDIO:{
1053 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1054 data_size= samples_size;
1055 /* XXX: could avoid copy if PCM 16 bits with same
1056 endianness as CPU */
1057 ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1063 /* Some bug in mpeg audio decoder gives */
1064 /* data_size < 0, it seems they are overflows */
1065 if (data_size <= 0) {
1066 /* no audio frame */
1069 data_buf = (uint8_t *)samples;
1070 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1071 (ist->st->codec->sample_rate * ist->st->codec->channels);
1073 case CODEC_TYPE_VIDEO:
1074 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1075 /* XXX: allocate picture correctly */
1076 avcodec_get_frame_defaults(&picture);
1078 ret = avcodec_decode_video(ist->st->codec,
1079 &picture, &got_picture, ptr, len);
1080 ist->st->quality= picture.quality;
1084 /* no picture yet */
1085 goto discard_packet;
1087 if (ist->st->codec->time_base.num != 0) {
1088 ist->next_pts += ((int64_t)AV_TIME_BASE *
1089 ist->st->codec->time_base.num) /
1090 ist->st->codec->time_base.den;
1094 case CODEC_TYPE_SUBTITLE:
1095 ret = avcodec_decode_subtitle(ist->st->codec,
1096 &subtitle, &got_subtitle, ptr, len);
1099 if (!got_subtitle) {
1100 goto discard_packet;
1102 subtitle_to_free = &subtitle;
1109 switch(ist->st->codec->codec_type) {
1110 case CODEC_TYPE_AUDIO:
1111 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1112 (ist->st->codec->sample_rate * ist->st->codec->channels);
1114 case CODEC_TYPE_VIDEO:
1115 if (ist->st->codec->time_base.num != 0) {
1116 ist->next_pts += ((int64_t)AV_TIME_BASE *
1117 ist->st->codec->time_base.num) /
1118 ist->st->codec->time_base.den;
1128 buffer_to_free = NULL;
1129 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1130 pre_process_video_frame(ist, (AVPicture *)&picture,
1134 // preprocess audio (volume)
1135 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1136 if (audio_volume != 256) {
1139 for(i=0;i<(data_size / sizeof(short));i++) {
1140 int v = ((*volp) * audio_volume + 128) >> 8;
1141 if (v < -32768) v = -32768;
1142 if (v > 32767) v = 32767;
1148 /* frame rate emulation */
1149 if (ist->st->codec->rate_emu) {
1150 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1151 int64_t now = av_gettime() - ist->start;
1159 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1160 is the one of the next displayed one */
1161 /* XXX: add mpeg4 too ? */
1162 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1163 if (ist->st->codec->pict_type != B_TYPE) {
1165 tmp = ist->last_ip_pts;
1166 ist->last_ip_pts = ist->frac_pts.val;
1167 ist->frac_pts.val = tmp;
1171 /* if output time reached then transcode raw format,
1172 encode packets and output them */
1173 if (start_time == 0 || ist->pts >= start_time)
1174 for(i=0;i<nb_ostreams;i++) {
1178 if (ost->source_index == ist_index) {
1179 os = output_files[ost->file_index];
1182 printf("%d: got pts=%0.3f %0.3f\n", i,
1183 (double)pkt->pts / AV_TIME_BASE,
1184 ((double)ist->pts / AV_TIME_BASE) -
1185 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1187 /* set the input output pts pairs */
1188 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1190 if (ost->encoding_needed) {
1191 switch(ost->st->codec->codec_type) {
1192 case CODEC_TYPE_AUDIO:
1193 do_audio_out(os, ost, ist, data_buf, data_size);
1195 case CODEC_TYPE_VIDEO:
1196 do_video_out(os, ost, ist, &picture, &frame_size);
1197 video_size += frame_size;
1198 if (do_vstats && frame_size)
1199 do_video_stats(os, ost, frame_size);
1201 case CODEC_TYPE_SUBTITLE:
1202 do_subtitle_out(os, ost, ist, &subtitle,
1209 AVFrame avframe; //FIXME/XXX remove this
1211 av_init_packet(&opkt);
1213 /* no reencoding needed : output the packet directly */
1214 /* force the input stream PTS */
1216 avcodec_get_frame_defaults(&avframe);
1217 ost->st->codec->coded_frame= &avframe;
1218 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1220 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1221 audio_size += data_size;
1222 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1223 video_size += data_size;
1227 opkt.stream_index= ost->index;
1228 if(pkt->pts != AV_NOPTS_VALUE)
1229 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);
1231 opkt.pts= AV_NOPTS_VALUE;
1235 if (pkt->dts == AV_NOPTS_VALUE)
1236 dts = ist->next_pts;
1238 dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1239 opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
1241 opkt.flags= pkt->flags;
1243 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1244 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1245 opkt.destruct= av_destruct_packet;
1247 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1248 ost->st->codec->frame_number++;
1249 ost->frame_number++;
1250 av_free_packet(&opkt);
1254 av_free(buffer_to_free);
1255 /* XXX: allocate the subtitles in the codec ? */
1256 if (subtitle_to_free) {
1257 if (subtitle_to_free->rects != NULL) {
1258 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1259 av_free(subtitle_to_free->rects[i].bitmap);
1260 av_free(subtitle_to_free->rects[i].rgba_palette);
1262 av_freep(&subtitle_to_free->rects);
1264 subtitle_to_free->num_rects = 0;
1265 subtitle_to_free = NULL;
1272 for(i=0;i<nb_ostreams;i++) {
1274 if (ost->source_index == ist_index) {
1275 AVCodecContext *enc= ost->st->codec;
1276 os = output_files[ost->file_index];
1278 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1280 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1283 if (ost->encoding_needed) {
1287 av_init_packet(&pkt);
1288 pkt.stream_index= ost->index;
1290 switch(ost->st->codec->codec_type) {
1291 case CODEC_TYPE_AUDIO:
1292 fifo_bytes = av_fifo_size(&ost->fifo);
1294 /* encode any samples remaining in fifo */
1295 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1296 int fs_tmp = enc->frame_size;
1297 enc->frame_size = fifo_bytes / (2 * enc->channels);
1298 if(av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes) == 0) {
1299 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1301 enc->frame_size = fs_tmp;
1304 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1307 pkt.flags |= PKT_FLAG_KEY;
1309 case CODEC_TYPE_VIDEO:
1310 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1312 if(enc->coded_frame && enc->coded_frame->key_frame)
1313 pkt.flags |= PKT_FLAG_KEY;
1314 if (ost->logfile && enc->stats_out) {
1315 fprintf(ost->logfile, "%s", enc->stats_out);
1324 pkt.data= bit_buffer;
1326 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1327 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1328 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1342 * The following code is the main loop of the file converter
1344 static int av_encode(AVFormatContext **output_files,
1345 int nb_output_files,
1346 AVFormatContext **input_files,
1348 AVStreamMap *stream_maps, int nb_stream_maps)
1350 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1351 AVFormatContext *is, *os;
1352 AVCodecContext *codec, *icodec;
1353 AVOutputStream *ost, **ost_table = NULL;
1354 AVInputStream *ist, **ist_table = NULL;
1355 AVInputFile *file_table;
1356 AVFormatContext *stream_no_data;
1359 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1363 /* input stream init */
1365 for(i=0;i<nb_input_files;i++) {
1366 is = input_files[i];
1367 file_table[i].ist_index = j;
1368 file_table[i].nb_streams = is->nb_streams;
1369 j += is->nb_streams;
1373 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1377 for(i=0;i<nb_istreams;i++) {
1378 ist = av_mallocz(sizeof(AVInputStream));
1384 for(i=0;i<nb_input_files;i++) {
1385 is = input_files[i];
1386 for(k=0;k<is->nb_streams;k++) {
1387 ist = ist_table[j++];
1388 ist->st = is->streams[k];
1389 ist->file_index = i;
1391 ist->discard = 1; /* the stream is discarded by default
1394 if (ist->st->codec->rate_emu) {
1395 ist->start = av_gettime();
1401 /* output stream init */
1403 for(i=0;i<nb_output_files;i++) {
1404 os = output_files[i];
1405 if (!os->nb_streams) {
1406 fprintf(stderr, "Output file does not contain any stream\n");
1409 nb_ostreams += os->nb_streams;
1411 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1412 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1416 /* Sanity check the mapping args -- do the input files & streams exist? */
1417 for(i=0;i<nb_stream_maps;i++) {
1418 int fi = stream_maps[i].file_index;
1419 int si = stream_maps[i].stream_index;
1421 if (fi < 0 || fi > nb_input_files - 1 ||
1422 si < 0 || si > file_table[fi].nb_streams - 1) {
1423 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1426 fi = stream_maps[i].sync_file_index;
1427 si = stream_maps[i].sync_stream_index;
1428 if (fi < 0 || fi > nb_input_files - 1 ||
1429 si < 0 || si > file_table[fi].nb_streams - 1) {
1430 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1435 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1438 for(i=0;i<nb_ostreams;i++) {
1439 ost = av_mallocz(sizeof(AVOutputStream));
1446 for(k=0;k<nb_output_files;k++) {
1447 os = output_files[k];
1448 for(i=0;i<os->nb_streams;i++) {
1450 ost = ost_table[n++];
1451 ost->file_index = k;
1453 ost->st = os->streams[i];
1454 if (nb_stream_maps > 0) {
1455 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1456 stream_maps[n-1].stream_index;
1458 /* Sanity check that the stream types match */
1459 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1460 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1461 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1462 ost->file_index, ost->index);
1467 /* get corresponding input stream index : we select the first one with the right type */
1469 for(j=0;j<nb_istreams;j++) {
1472 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1473 ost->source_index = j;
1480 /* try again and reuse existing stream */
1481 for(j=0;j<nb_istreams;j++) {
1483 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1484 ost->source_index = j;
1489 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1490 ost->file_index, ost->index);
1495 ist = ist_table[ost->source_index];
1497 ost->sync_ist = (nb_stream_maps > 0) ?
1498 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1499 stream_maps[n-1].sync_stream_index] : ist;
1503 /* for each output stream, we compute the right encoding parameters */
1504 for(i=0;i<nb_ostreams;i++) {
1506 ist = ist_table[ost->source_index];
1508 codec = ost->st->codec;
1509 icodec = ist->st->codec;
1511 if (ost->st->stream_copy) {
1512 /* if stream_copy is selected, no need to decode or encode */
1513 codec->codec_id = icodec->codec_id;
1514 codec->codec_type = icodec->codec_type;
1515 if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1516 codec->bit_rate = icodec->bit_rate;
1517 codec->extradata= icodec->extradata;
1518 codec->extradata_size= icodec->extradata_size;
1519 if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1520 codec->time_base = icodec->time_base;
1522 codec->time_base = ist->st->time_base;
1523 switch(codec->codec_type) {
1524 case CODEC_TYPE_AUDIO:
1525 codec->sample_rate = icodec->sample_rate;
1526 codec->channels = icodec->channels;
1527 codec->frame_size = icodec->frame_size;
1528 codec->block_align= icodec->block_align;
1530 case CODEC_TYPE_VIDEO:
1532 fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1535 codec->pix_fmt = icodec->pix_fmt;
1536 codec->width = icodec->width;
1537 codec->height = icodec->height;
1538 codec->has_b_frames = icodec->has_b_frames;
1540 case CODEC_TYPE_SUBTITLE:
1546 switch(codec->codec_type) {
1547 case CODEC_TYPE_AUDIO:
1548 if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1551 if (codec->channels == icodec->channels &&
1552 codec->sample_rate == icodec->sample_rate) {
1553 ost->audio_resample = 0;
1555 if (codec->channels != icodec->channels &&
1556 (icodec->codec_id == CODEC_ID_AC3 ||
1557 icodec->codec_id == CODEC_ID_DTS)) {
1558 /* Special case for 5:1 AC3 and DTS input */
1559 /* and mono or stereo output */
1560 /* Request specific number of channels */
1561 icodec->channels = codec->channels;
1562 if (codec->sample_rate == icodec->sample_rate)
1563 ost->audio_resample = 0;
1565 ost->audio_resample = 1;
1568 ost->audio_resample = 1;
1571 if(audio_sync_method>1)
1572 ost->audio_resample = 1;
1574 if(ost->audio_resample){
1575 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1576 codec->sample_rate, icodec->sample_rate);
1578 printf("Can't resample. Aborting.\n");
1582 ist->decoding_needed = 1;
1583 ost->encoding_needed = 1;
1585 case CODEC_TYPE_VIDEO:
1586 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1587 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1588 ost->video_resample = ((codec->width != icodec->width -
1589 (frame_leftBand + frame_rightBand) +
1590 (frame_padleft + frame_padright)) ||
1591 (codec->height != icodec->height -
1592 (frame_topBand + frame_bottomBand) +
1593 (frame_padtop + frame_padbottom)) ||
1594 (codec->pix_fmt != icodec->pix_fmt));
1595 if (ost->video_crop) {
1596 ost->topBand = frame_topBand;
1597 ost->leftBand = frame_leftBand;
1599 if (ost->video_pad) {
1600 ost->padtop = frame_padtop;
1601 ost->padleft = frame_padleft;
1602 ost->padbottom = frame_padbottom;
1603 ost->padright = frame_padright;
1604 if (!ost->video_resample) {
1605 avcodec_get_frame_defaults(&ost->pict_tmp);
1606 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1607 codec->width, codec->height ) )
1611 if (ost->video_resample) {
1612 avcodec_get_frame_defaults(&ost->pict_tmp);
1613 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1614 codec->width, codec->height ) )
1617 ost->img_resample_ctx = sws_getContext(
1618 icodec->width - (frame_leftBand + frame_rightBand),
1619 icodec->height - (frame_topBand + frame_bottomBand),
1621 codec->width - (frame_padleft + frame_padright),
1622 codec->height - (frame_padtop + frame_padbottom),
1624 sws_flags, NULL, NULL, NULL);
1625 if (ost->img_resample_ctx == NULL) {
1626 fprintf(stderr, "Cannot get resampling context\n");
1629 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1631 ost->encoding_needed = 1;
1632 ist->decoding_needed = 1;
1634 case CODEC_TYPE_SUBTITLE:
1635 ost->encoding_needed = 1;
1636 ist->decoding_needed = 1;
1643 if (ost->encoding_needed &&
1644 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1645 char logfilename[1024];
1650 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1652 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1653 if (codec->flags & CODEC_FLAG_PASS1) {
1654 f = fopen(logfilename, "w");
1656 perror(logfilename);
1661 /* read the log file */
1662 f = fopen(logfilename, "r");
1664 perror(logfilename);
1667 fseek(f, 0, SEEK_END);
1669 fseek(f, 0, SEEK_SET);
1670 logbuffer = av_malloc(size + 1);
1672 fprintf(stderr, "Could not allocate log buffer\n");
1675 size = fread(logbuffer, 1, size, f);
1677 logbuffer[size] = '\0';
1678 codec->stats_in = logbuffer;
1682 if(codec->codec_type == CODEC_TYPE_VIDEO){
1683 int size= codec->width * codec->height;
1684 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1689 bit_buffer = av_malloc(bit_buffer_size);
1693 /* dump the file output parameters - cannot be done before in case
1695 for(i=0;i<nb_output_files;i++) {
1696 dump_format(output_files[i], i, output_files[i]->filename, 1);
1699 /* dump the stream mapping */
1701 fprintf(stderr, "Stream mapping:\n");
1702 for(i=0;i<nb_ostreams;i++) {
1704 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1705 ist_table[ost->source_index]->file_index,
1706 ist_table[ost->source_index]->index,
1709 if (ost->sync_ist != ist_table[ost->source_index])
1710 fprintf(stderr, " [sync #%d.%d]",
1711 ost->sync_ist->file_index,
1712 ost->sync_ist->index);
1713 fprintf(stderr, "\n");
1717 /* open each encoder */
1718 for(i=0;i<nb_ostreams;i++) {
1720 if (ost->encoding_needed) {
1722 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1724 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1725 ost->file_index, ost->index);
1728 if (avcodec_open(ost->st->codec, codec) < 0) {
1729 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1730 ost->file_index, ost->index);
1733 extra_size += ost->st->codec->extradata_size;
1737 /* open each decoder */
1738 for(i=0;i<nb_istreams;i++) {
1740 if (ist->decoding_needed) {
1742 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1744 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1745 ist->st->codec->codec_id, ist->file_index, ist->index);
1748 if (avcodec_open(ist->st->codec, codec) < 0) {
1749 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1750 ist->file_index, ist->index);
1753 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1754 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1759 for(i=0;i<nb_istreams;i++) {
1761 is = input_files[ist->file_index];
1763 ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1764 if(ist->st->start_time == AV_NOPTS_VALUE)
1766 if(input_files_ts_offset[ist->file_index])
1767 ist->next_pts= AV_NOPTS_VALUE;
1771 /* compute buffer size max (should use a complete heuristic) */
1772 for(i=0;i<nb_input_files;i++) {
1773 file_table[i].buffer_size_max = 2048;
1776 /* set meta data information from input file if required */
1777 for (i=0;i<nb_meta_data_maps;i++) {
1778 AVFormatContext *out_file;
1779 AVFormatContext *in_file;
1781 int out_file_index = meta_data_maps[i].out_file;
1782 int in_file_index = meta_data_maps[i].in_file;
1783 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1784 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1785 ret = AVERROR(EINVAL);
1788 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1789 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1790 ret = AVERROR(EINVAL);
1794 out_file = output_files[out_file_index];
1795 in_file = input_files[in_file_index];
1797 strcpy(out_file->title, in_file->title);
1798 strcpy(out_file->author, in_file->author);
1799 strcpy(out_file->copyright, in_file->copyright);
1800 strcpy(out_file->comment, in_file->comment);
1801 strcpy(out_file->album, in_file->album);
1802 out_file->year = in_file->year;
1803 out_file->track = in_file->track;
1804 strcpy(out_file->genre, in_file->genre);
1807 /* open files and write file headers */
1808 for(i=0;i<nb_output_files;i++) {
1809 os = output_files[i];
1810 if (av_write_header(os) < 0) {
1811 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1812 ret = AVERROR(EINVAL);
1817 if ( !using_stdin && verbose >= 0) {
1818 fprintf(stderr, "Press [q] to stop encoding\n");
1819 url_set_interrupt_cb(decode_interrupt_cb);
1826 for(; received_sigterm == 0;) {
1827 int file_index, ist_index;
1835 /* if 'q' pressed, exits */
1839 /* read_key() returns 0 on EOF */
1845 /* select the stream that we must read now by looking at the
1846 smallest output pts */
1848 for(i=0;i<nb_ostreams;i++) {
1851 os = output_files[ost->file_index];
1852 ist = ist_table[ost->source_index];
1853 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1854 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1856 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1857 ipts = (double)ist->pts;
1858 if (!file_table[ist->file_index].eof_reached){
1859 if(ipts < ipts_min) {
1861 if(input_sync ) file_index = ist->file_index;
1863 if(opts < opts_min) {
1865 if(!input_sync) file_index = ist->file_index;
1868 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1873 /* if none, if is finished */
1874 if (file_index < 0) {
1878 /* finish if recording time exhausted */
1879 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1882 /* finish if limit size exhausted */
1883 if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1886 /* read a frame from it and output it in the fifo */
1887 is = input_files[file_index];
1888 if (av_read_frame(is, &pkt) < 0) {
1889 file_table[file_index].eof_reached = 1;
1890 if (opt_shortest) break; else continue; //
1894 stream_no_data = is;
1899 av_pkt_dump(stdout, &pkt, do_hex_dump);
1901 /* the following test is needed in case new streams appear
1902 dynamically in stream : we ignore them */
1903 if (pkt.stream_index >= file_table[file_index].nb_streams)
1904 goto discard_packet;
1905 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1906 ist = ist_table[ist_index];
1908 goto discard_packet;
1910 // 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);
1911 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1912 int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1913 if(FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1914 input_files_ts_offset[ist->file_index]-= delta;
1916 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1917 for(i=0; i<file_table[file_index].nb_streams; i++){
1918 int index= file_table[file_index].ist_index + i;
1919 ist_table[index]->next_pts += delta;
1920 ist_table[index]->is_start=1;
1925 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1926 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1929 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1930 ist->file_index, ist->index);
1932 av_free_packet(&pkt);
1937 av_free_packet(&pkt);
1939 /* dump report by using the output first video and audio streams */
1940 print_report(output_files, ost_table, nb_ostreams, 0);
1943 /* at the end of stream, we must flush the decoder buffers */
1944 for(i=0;i<nb_istreams;i++) {
1946 if (ist->decoding_needed) {
1947 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1953 /* write the trailer if needed and close file */
1954 for(i=0;i<nb_output_files;i++) {
1955 os = output_files[i];
1956 av_write_trailer(os);
1959 /* dump report by using the first video and audio streams */
1960 print_report(output_files, ost_table, nb_ostreams, 1);
1962 /* close each encoder */
1963 for(i=0;i<nb_ostreams;i++) {
1965 if (ost->encoding_needed) {
1966 av_freep(&ost->st->codec->stats_in);
1967 avcodec_close(ost->st->codec);
1971 /* close each decoder */
1972 for(i=0;i<nb_istreams;i++) {
1974 if (ist->decoding_needed) {
1975 avcodec_close(ist->st->codec);
1983 av_freep(&bit_buffer);
1984 av_free(file_table);
1987 for(i=0;i<nb_istreams;i++) {
1994 for(i=0;i<nb_ostreams;i++) {
1998 fclose(ost->logfile);
1999 ost->logfile = NULL;
2001 av_fifo_free(&ost->fifo); /* works even if fifo is not
2002 initialized but set to zero */
2003 av_free(ost->pict_tmp.data[0]);
2004 if (ost->video_resample)
2005 sws_freeContext(ost->img_resample_ctx);
2006 if (ost->audio_resample)
2007 audio_resample_close(ost->resample);
2015 ret = AVERROR(ENOMEM);
2020 int file_read(const char *filename)
2023 unsigned char buffer[1024];
2026 if (url_open(&h, filename, O_RDONLY) < 0) {
2027 printf("could not open '%s'\n", filename);
2031 len = url_read(h, buffer, sizeof(buffer));
2034 for(i=0;i<len;i++) putchar(buffer[i]);
2041 static void opt_format(const char *arg)
2043 /* compatibility stuff for pgmyuv */
2044 if (!strcmp(arg, "pgmyuv")) {
2045 pgmyuv_compatibility_hack=1;
2046 // opt_image_format(arg);
2050 file_iformat = av_find_input_format(arg);
2051 file_oformat = guess_format(arg, NULL, NULL);
2052 if (!file_iformat && !file_oformat) {
2053 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2058 static void opt_video_rc_eq(char *arg)
2063 static void opt_video_rc_override_string(char *arg)
2065 video_rc_override_string = arg;
2068 static void opt_me_threshold(const char *arg)
2070 me_threshold = atoi(arg);
2073 static void opt_verbose(const char *arg)
2075 verbose = atoi(arg);
2076 av_log_level = atoi(arg);
2079 static void opt_frame_rate(const char *arg)
2081 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2082 fprintf(stderr, "Incorrect frame rate\n");
2087 static void opt_frame_crop_top(const char *arg)
2089 frame_topBand = atoi(arg);
2090 if (frame_topBand < 0) {
2091 fprintf(stderr, "Incorrect top crop size\n");
2094 if ((frame_topBand % 2) != 0) {
2095 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2098 if ((frame_topBand) >= frame_height){
2099 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2102 frame_height -= frame_topBand;
2105 static void opt_frame_crop_bottom(const char *arg)
2107 frame_bottomBand = atoi(arg);
2108 if (frame_bottomBand < 0) {
2109 fprintf(stderr, "Incorrect bottom crop size\n");
2112 if ((frame_bottomBand % 2) != 0) {
2113 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2116 if ((frame_bottomBand) >= frame_height){
2117 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2120 frame_height -= frame_bottomBand;
2123 static void opt_frame_crop_left(const char *arg)
2125 frame_leftBand = atoi(arg);
2126 if (frame_leftBand < 0) {
2127 fprintf(stderr, "Incorrect left crop size\n");
2130 if ((frame_leftBand % 2) != 0) {
2131 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2134 if ((frame_leftBand) >= frame_width){
2135 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2138 frame_width -= frame_leftBand;
2141 static void opt_frame_crop_right(const char *arg)
2143 frame_rightBand = atoi(arg);
2144 if (frame_rightBand < 0) {
2145 fprintf(stderr, "Incorrect right crop size\n");
2148 if ((frame_rightBand % 2) != 0) {
2149 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2152 if ((frame_rightBand) >= frame_width){
2153 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2156 frame_width -= frame_rightBand;
2159 static void opt_frame_size(const char *arg)
2161 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2162 fprintf(stderr, "Incorrect frame size\n");
2165 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2166 fprintf(stderr, "Frame size must be a multiple of 2\n");
2172 #define SCALEBITS 10
2173 #define ONE_HALF (1 << (SCALEBITS - 1))
2174 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2176 #define RGB_TO_Y(r, g, b) \
2177 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2178 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2180 #define RGB_TO_U(r1, g1, b1, shift)\
2181 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2182 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2184 #define RGB_TO_V(r1, g1, b1, shift)\
2185 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2186 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2188 static void opt_pad_color(const char *arg) {
2189 /* Input is expected to be six hex digits similar to
2190 how colors are expressed in html tags (but without the #) */
2191 int rgb = strtol(arg, NULL, 16);
2195 g = ((rgb >> 8) & 255);
2198 padcolor[0] = RGB_TO_Y(r,g,b);
2199 padcolor[1] = RGB_TO_U(r,g,b,0);
2200 padcolor[2] = RGB_TO_V(r,g,b,0);
2203 static void opt_frame_pad_top(const char *arg)
2205 frame_padtop = atoi(arg);
2206 if (frame_padtop < 0) {
2207 fprintf(stderr, "Incorrect top pad size\n");
2210 if ((frame_padtop % 2) != 0) {
2211 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2216 static void opt_frame_pad_bottom(const char *arg)
2218 frame_padbottom = atoi(arg);
2219 if (frame_padbottom < 0) {
2220 fprintf(stderr, "Incorrect bottom pad size\n");
2223 if ((frame_padbottom % 2) != 0) {
2224 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2230 static void opt_frame_pad_left(const char *arg)
2232 frame_padleft = atoi(arg);
2233 if (frame_padleft < 0) {
2234 fprintf(stderr, "Incorrect left pad size\n");
2237 if ((frame_padleft % 2) != 0) {
2238 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2244 static void opt_frame_pad_right(const char *arg)
2246 frame_padright = atoi(arg);
2247 if (frame_padright < 0) {
2248 fprintf(stderr, "Incorrect right pad size\n");
2251 if ((frame_padright % 2) != 0) {
2252 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2258 static void opt_frame_pix_fmt(const char *arg)
2260 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2263 static void opt_frame_aspect_ratio(const char *arg)
2269 p = strchr(arg, ':');
2271 x = strtol(arg, (char **)&arg, 10);
2273 y = strtol(arg+1, (char **)&arg, 10);
2275 ar = (double)x / (double)y;
2277 ar = strtod(arg, (char **)&arg);
2280 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2283 frame_aspect_ratio = ar;
2286 static void opt_qscale(const char *arg)
2288 video_qscale = atof(arg);
2289 if (video_qscale <= 0 ||
2290 video_qscale > 255) {
2291 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2296 static void opt_qdiff(const char *arg)
2298 video_qdiff = atoi(arg);
2299 if (video_qdiff < 0 ||
2301 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2306 static void opt_strict(const char *arg)
2311 static void opt_top_field_first(const char *arg)
2313 top_field_first= atoi(arg);
2316 static void opt_thread_count(const char *arg)
2318 thread_count= atoi(arg);
2319 #if !defined(HAVE_THREADS)
2321 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2325 static void opt_audio_rate(const char *arg)
2327 audio_sample_rate = atoi(arg);
2330 static void opt_audio_channels(const char *arg)
2332 audio_channels = atoi(arg);
2335 static void opt_video_channel(const char *arg)
2337 video_channel = strtol(arg, NULL, 0);
2340 static void opt_video_standard(const char *arg)
2342 video_standard = av_strdup(arg);
2345 static void opt_codec(int *pstream_copy, int *pcodec_id,
2346 int codec_type, const char *arg)
2350 if (!strcmp(arg, "copy")) {
2355 if (!strcmp(p->name, arg) && p->type == codec_type)
2360 fprintf(stderr, "Unknown codec '%s'\n", arg);
2368 static void opt_audio_codec(const char *arg)
2370 opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2373 static void opt_audio_tag(const char *arg)
2376 audio_codec_tag= strtol(arg, &tail, 0);
2379 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2382 static void opt_video_tag(const char *arg)
2385 video_codec_tag= strtol(arg, &tail, 0);
2388 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2391 static void add_frame_hooker(const char *arg)
2396 char *args = av_strdup(arg);
2400 argv[0] = strtok(args, " ");
2401 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2404 i = frame_hook_add(argc, argv);
2407 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2412 const char *motion_str[] = {
2425 static void opt_motion_estimation(const char *arg)
2431 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2434 if (!strcmp(*p, arg))
2438 me_method = (p - motion_str) + 1;
2441 static void opt_video_codec(const char *arg)
2443 opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2446 static void opt_subtitle_codec(const char *arg)
2448 opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2451 static void opt_map(const char *arg)
2457 m = &stream_maps[nb_stream_maps++];
2459 m->file_index = strtol(arg, (char **)&p, 0);
2463 m->stream_index = strtol(p, (char **)&p, 0);
2466 m->sync_file_index = strtol(p, (char **)&p, 0);
2469 m->sync_stream_index = strtol(p, (char **)&p, 0);
2471 m->sync_file_index = m->file_index;
2472 m->sync_stream_index = m->stream_index;
2476 static void opt_map_meta_data(const char *arg)
2482 m = &meta_data_maps[nb_meta_data_maps++];
2484 m->out_file = strtol(arg, (char **)&p, 0);
2488 m->in_file = strtol(p, (char **)&p, 0);
2491 static void opt_recording_time(const char *arg)
2493 recording_time = parse_date(arg, 1);
2496 static void opt_start_time(const char *arg)
2498 start_time = parse_date(arg, 1);
2501 static void opt_rec_timestamp(const char *arg)
2503 rec_timestamp = parse_date(arg, 0) / 1000000;
2506 static void opt_input_ts_offset(const char *arg)
2508 input_ts_offset = parse_date(arg, 1);
2511 static void opt_input_file(const char *filename)
2513 AVFormatContext *ic;
2514 AVFormatParameters params, *ap = ¶ms;
2515 int err, i, ret, rfps, rfps_base;
2518 if (!strcmp(filename, "-"))
2521 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2522 !strcmp( filename, "/dev/stdin" );
2524 /* get default parameters from command line */
2525 ic = av_alloc_format_context();
2527 memset(ap, 0, sizeof(*ap));
2528 ap->prealloced_context = 1;
2529 ap->sample_rate = audio_sample_rate;
2530 ap->channels = audio_channels;
2531 ap->time_base.den = frame_rate;
2532 ap->time_base.num = frame_rate_base;
2533 ap->width = frame_width + frame_padleft + frame_padright;
2534 ap->height = frame_height + frame_padtop + frame_padbottom;
2535 ap->pix_fmt = frame_pix_fmt;
2536 ap->channel = video_channel;
2537 ap->standard = video_standard;
2538 ap->video_codec_id = video_codec_id;
2539 ap->audio_codec_id = audio_codec_id;
2540 if(pgmyuv_compatibility_hack)
2541 ap->video_codec_id= CODEC_ID_PGMYUV;
2543 for(i=0; i<opt_name_count; i++){
2544 const AVOption *opt;
2545 double d= av_get_double(avformat_opts, opt_names[i], &opt);
2546 if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2547 av_set_double(ic, opt_names[i], d);
2549 /* open the input file with generic libav function */
2550 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2552 print_error(filename, err);
2556 ic->loop_input = loop_input;
2558 /* If not enough info to get the stream parameters, we decode the
2559 first frames to get it. (used in mpeg case for example) */
2560 ret = av_find_stream_info(ic);
2561 if (ret < 0 && verbose >= 0) {
2562 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2566 timestamp = start_time;
2567 /* add the stream start time */
2568 if (ic->start_time != AV_NOPTS_VALUE)
2569 timestamp += ic->start_time;
2571 /* if seeking requested, we execute it */
2572 if (start_time != 0) {
2573 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2575 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2576 filename, (double)timestamp / AV_TIME_BASE);
2578 /* reset seek info */
2582 /* update the current parameters so that they match the one of the input stream */
2583 for(i=0;i<ic->nb_streams;i++) {
2585 AVCodecContext *enc = ic->streams[i]->codec;
2586 #if defined(HAVE_THREADS)
2588 avcodec_thread_init(enc, thread_count);
2590 enc->thread_count= thread_count;
2591 switch(enc->codec_type) {
2592 case CODEC_TYPE_AUDIO:
2593 for(j=0; j<opt_name_count; j++){
2594 const AVOption *opt;
2595 double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt);
2596 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2597 av_set_double(enc, opt_names[j], d);
2599 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2600 audio_channels = enc->channels;
2601 audio_sample_rate = enc->sample_rate;
2603 ic->streams[i]->discard= AVDISCARD_ALL;
2605 case CODEC_TYPE_VIDEO:
2606 for(j=0; j<opt_name_count; j++){
2607 const AVOption *opt;
2608 double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt);
2609 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2610 av_set_double(enc, opt_names[j], d);
2612 frame_height = enc->height;
2613 frame_width = enc->width;
2614 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2615 frame_pix_fmt = enc->pix_fmt;
2616 rfps = ic->streams[i]->r_frame_rate.num;
2617 rfps_base = ic->streams[i]->r_frame_rate.den;
2618 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2620 enc->debug |= FF_DEBUG_MV;
2622 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2625 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2626 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2628 (float)rfps / rfps_base, rfps, rfps_base);
2630 /* update the current frame rate to match the stream frame rate */
2632 frame_rate_base = rfps_base;
2634 enc->rate_emu = rate_emu;
2636 ic->streams[i]->discard= AVDISCARD_ALL;
2637 else if(video_discard)
2638 ic->streams[i]->discard= video_discard;
2640 case CODEC_TYPE_DATA:
2642 case CODEC_TYPE_SUBTITLE:
2644 case CODEC_TYPE_UNKNOWN:
2651 input_files[nb_input_files] = ic;
2652 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2653 /* dump the file content */
2655 dump_format(ic, nb_input_files, filename, 0);
2658 file_iformat = NULL;
2659 file_oformat = NULL;
2666 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2668 int has_video, has_audio, i, j;
2669 AVFormatContext *ic;
2673 for(j=0;j<nb_input_files;j++) {
2674 ic = input_files[j];
2675 for(i=0;i<ic->nb_streams;i++) {
2676 AVCodecContext *enc = ic->streams[i]->codec;
2677 switch(enc->codec_type) {
2678 case CODEC_TYPE_AUDIO:
2681 case CODEC_TYPE_VIDEO:
2684 case CODEC_TYPE_DATA:
2685 case CODEC_TYPE_UNKNOWN:
2686 case CODEC_TYPE_SUBTITLE:
2693 *has_video_ptr = has_video;
2694 *has_audio_ptr = has_audio;
2697 static void new_video_stream(AVFormatContext *oc)
2700 AVCodecContext *video_enc;
2703 st = av_new_stream(oc, oc->nb_streams);
2705 fprintf(stderr, "Could not alloc stream\n");
2708 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2709 video_bitstream_filters= NULL;
2711 #if defined(HAVE_THREADS)
2713 avcodec_thread_init(st->codec, thread_count);
2716 video_enc = st->codec;
2719 video_enc->codec_tag= video_codec_tag;
2721 if( (video_global_header&1)
2722 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2723 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2724 avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2726 if(video_global_header&2){
2727 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2728 avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2731 if (video_stream_copy) {
2732 st->stream_copy = 1;
2733 video_enc->codec_type = CODEC_TYPE_VIDEO;
2739 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2740 if (video_codec_id != CODEC_ID_NONE)
2741 codec_id = video_codec_id;
2743 video_enc->codec_id = codec_id;
2744 codec = avcodec_find_encoder(codec_id);
2746 for(i=0; i<opt_name_count; i++){
2747 const AVOption *opt;
2748 double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt);
2749 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2750 av_set_double(video_enc, opt_names[i], d);
2753 video_enc->time_base.den = frame_rate;
2754 video_enc->time_base.num = frame_rate_base;
2755 if(codec && codec->supported_framerates){
2756 const AVRational *p= codec->supported_framerates;
2757 AVRational req= (AVRational){frame_rate, frame_rate_base};
2758 const AVRational *best=NULL;
2759 AVRational best_error= (AVRational){INT_MAX, 1};
2760 for(; p->den!=0; p++){
2761 AVRational error= av_sub_q(req, *p);
2762 if(error.num <0) error.num *= -1;
2763 if(av_cmp_q(error, best_error) < 0){
2768 video_enc->time_base.den= best->num;
2769 video_enc->time_base.num= best->den;
2772 video_enc->width = frame_width + frame_padright + frame_padleft;
2773 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2774 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2775 video_enc->pix_fmt = frame_pix_fmt;
2777 if(codec && codec->pix_fmts){
2778 const enum PixelFormat *p= codec->pix_fmts;
2780 if(*p == video_enc->pix_fmt)
2784 video_enc->pix_fmt = codec->pix_fmts[0];
2788 video_enc->gop_size = 0;
2789 if (video_qscale || same_quality) {
2790 video_enc->flags |= CODEC_FLAG_QSCALE;
2791 video_enc->global_quality=
2792 st->quality = FF_QP2LAMBDA * video_qscale;
2796 video_enc->intra_matrix = intra_matrix;
2798 video_enc->inter_matrix = inter_matrix;
2800 video_enc->max_qdiff = video_qdiff;
2801 video_enc->rc_eq = video_rc_eq;
2802 video_enc->thread_count = thread_count;
2803 p= video_rc_override_string;
2806 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2808 fprintf(stderr, "error parsing rc_override\n");
2811 video_enc->rc_override=
2812 av_realloc(video_enc->rc_override,
2813 sizeof(RcOverride)*(i+1));
2814 video_enc->rc_override[i].start_frame= start;
2815 video_enc->rc_override[i].end_frame = end;
2817 video_enc->rc_override[i].qscale= q;
2818 video_enc->rc_override[i].quality_factor= 1.0;
2821 video_enc->rc_override[i].qscale= 0;
2822 video_enc->rc_override[i].quality_factor= -q/100.0;
2827 video_enc->rc_override_count=i;
2828 if (!video_enc->rc_initial_buffer_occupancy)
2829 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2830 video_enc->me_threshold= me_threshold;
2831 video_enc->intra_dc_precision= intra_dc_precision - 8;
2832 video_enc->strict_std_compliance = strict;
2835 video_enc->flags|= CODEC_FLAG_PSNR;
2837 video_enc->me_method = me_method;
2842 video_enc->flags |= CODEC_FLAG_PASS1;
2844 video_enc->flags |= CODEC_FLAG_PASS2;
2849 /* reset some key parameters */
2851 video_codec_id = CODEC_ID_NONE;
2852 video_stream_copy = 0;
2855 static void new_audio_stream(AVFormatContext *oc)
2858 AVCodecContext *audio_enc;
2861 st = av_new_stream(oc, oc->nb_streams);
2863 fprintf(stderr, "Could not alloc stream\n");
2867 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2868 audio_bitstream_filters= NULL;
2870 #if defined(HAVE_THREADS)
2872 avcodec_thread_init(st->codec, thread_count);
2875 audio_enc = st->codec;
2876 audio_enc->codec_type = CODEC_TYPE_AUDIO;
2877 audio_enc->strict_std_compliance = strict;
2880 audio_enc->codec_tag= audio_codec_tag;
2882 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2883 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2884 avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2886 if (audio_stream_copy) {
2887 st->stream_copy = 1;
2888 audio_enc->channels = audio_channels;
2890 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2892 for(i=0; i<opt_name_count; i++){
2893 const AVOption *opt;
2894 double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt);
2895 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2896 av_set_double(audio_enc, opt_names[i], d);
2899 if (audio_codec_id != CODEC_ID_NONE)
2900 codec_id = audio_codec_id;
2901 audio_enc->codec_id = codec_id;
2903 if (audio_qscale > QSCALE_NONE) {
2904 audio_enc->flags |= CODEC_FLAG_QSCALE;
2905 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
2907 audio_enc->thread_count = thread_count;
2908 audio_enc->channels = audio_channels;
2910 audio_enc->sample_rate = audio_sample_rate;
2911 audio_enc->time_base= (AVRational){1, audio_sample_rate};
2912 if (audio_language) {
2913 pstrcpy(st->language, sizeof(st->language), audio_language);
2914 av_free(audio_language);
2915 audio_language = NULL;
2918 /* reset some key parameters */
2920 audio_codec_id = CODEC_ID_NONE;
2921 audio_stream_copy = 0;
2924 static void opt_new_subtitle_stream(void)
2926 AVFormatContext *oc;
2928 AVCodecContext *subtitle_enc;
2931 if (nb_output_files <= 0) {
2932 fprintf(stderr, "At least one output file must be specified\n");
2935 oc = output_files[nb_output_files - 1];
2937 st = av_new_stream(oc, oc->nb_streams);
2939 fprintf(stderr, "Could not alloc stream\n");
2943 subtitle_enc = st->codec;
2944 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
2945 if (subtitle_stream_copy) {
2946 st->stream_copy = 1;
2948 for(i=0; i<opt_name_count; i++){
2949 const AVOption *opt;
2950 double d= av_get_double(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt);
2951 if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2952 av_set_double(subtitle_enc, opt_names[i], d);
2954 subtitle_enc->codec_id = subtitle_codec_id;
2957 if (subtitle_language) {
2958 pstrcpy(st->language, sizeof(st->language), subtitle_language);
2959 av_free(subtitle_language);
2960 subtitle_language = NULL;
2963 subtitle_codec_id = CODEC_ID_NONE;
2964 subtitle_stream_copy = 0;
2967 static void opt_new_audio_stream(void)
2969 AVFormatContext *oc;
2970 if (nb_output_files <= 0) {
2971 fprintf(stderr, "At least one output file must be specified\n");
2974 oc = output_files[nb_output_files - 1];
2975 new_audio_stream(oc);
2978 static void opt_new_video_stream(void)
2980 AVFormatContext *oc;
2981 if (nb_output_files <= 0) {
2982 fprintf(stderr, "At least one output file must be specified\n");
2985 oc = output_files[nb_output_files - 1];
2986 new_video_stream(oc);
2989 static void opt_output_file(const char *filename)
2991 AVFormatContext *oc;
2992 int use_video, use_audio, input_has_video, input_has_audio, i;
2993 AVFormatParameters params, *ap = ¶ms;
2995 if (!strcmp(filename, "-"))
2998 oc = av_alloc_format_context();
3000 if (!file_oformat) {
3001 file_oformat = guess_format(NULL, filename, NULL);
3002 if (!file_oformat) {
3003 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3009 oc->oformat = file_oformat;
3010 pstrcpy(oc->filename, sizeof(oc->filename), filename);
3012 if (!strcmp(file_oformat->name, "ffm") &&
3013 strstart(filename, "http:", NULL)) {
3014 /* special case for files sent to ffserver: we get the stream
3015 parameters from ffserver */
3016 if (read_ffserver_streams(oc, filename) < 0) {
3017 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3021 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3022 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3024 /* disable if no corresponding type found and at least one
3026 if (nb_input_files > 0) {
3027 check_audio_video_inputs(&input_has_video, &input_has_audio);
3028 if (!input_has_video)
3030 if (!input_has_audio)
3034 /* manual disable */
3035 if (audio_disable) {
3038 if (video_disable) {
3043 new_video_stream(oc);
3047 new_audio_stream(oc);
3050 oc->timestamp = rec_timestamp;
3053 pstrcpy(oc->title, sizeof(oc->title), str_title);
3055 pstrcpy(oc->author, sizeof(oc->author), str_author);
3057 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3059 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3061 pstrcpy(oc->album, sizeof(oc->album), str_album);
3064 output_files[nb_output_files++] = oc;
3066 /* check filename in case of an image number is expected */
3067 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3068 if (!av_filename_number_test(oc->filename)) {
3069 print_error(oc->filename, AVERROR_NUMEXPECTED);
3074 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3075 /* test if it already exists to avoid loosing precious files */
3076 if (!file_overwrite &&
3077 (strchr(filename, ':') == NULL ||
3078 strstart(filename, "file:", NULL))) {
3079 if (url_exist(filename)) {
3082 if ( !using_stdin ) {
3083 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3086 if (toupper(c) != 'Y') {
3087 fprintf(stderr, "Not overwriting - exiting\n");
3092 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3099 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3100 fprintf(stderr, "Could not open '%s'\n", filename);
3105 memset(ap, 0, sizeof(*ap));
3106 if (av_set_parameters(oc, ap) < 0) {
3107 fprintf(stderr, "%s: Invalid encoding parameters\n",
3112 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3113 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3114 oc->loop_output = loop_output;
3116 for(i=0; i<opt_name_count; i++){
3117 const AVOption *opt;
3118 double d = av_get_double(avformat_opts, opt_names[i], &opt);
3119 if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3120 av_set_double(oc, opt_names[i], d);
3123 /* reset some options */
3124 file_oformat = NULL;
3125 file_iformat = NULL;
3128 /* same option as mencoder */
3129 static void opt_pass(const char *pass_str)
3132 pass = atoi(pass_str);
3133 if (pass != 1 && pass != 2) {
3134 fprintf(stderr, "pass number can be only 1 or 2\n");
3140 #if defined(__MINGW32__) || defined(CONFIG_OS2)
3141 static int64_t getutime(void)
3143 return av_gettime();
3146 static int64_t getutime(void)
3148 struct rusage rusage;
3150 getrusage(RUSAGE_SELF, &rusage);
3151 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3155 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3156 extern int ffm_nopts;
3159 static void show_formats(void)
3161 AVInputFormat *ifmt;
3162 AVOutputFormat *ofmt;
3165 const char **pp, *last_name;
3167 printf("File formats:\n");
3172 const char *name=NULL;
3173 const char *long_name=NULL;
3175 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3176 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3177 strcmp(ofmt->name, last_name)>0){
3179 long_name= ofmt->long_name;
3183 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3184 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3185 strcmp(ifmt->name, last_name)>0){
3187 long_name= ifmt->long_name;
3190 if(name && strcmp(ifmt->name, name)==0)
3202 long_name ? long_name:" ");
3206 printf("Codecs:\n");
3212 const char *type_str;
3215 for(p = first_avcodec; p != NULL; p = p->next) {
3216 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3217 strcmp(p->name, last_name)>0){
3219 decode= encode= cap=0;
3221 if(p2 && strcmp(p->name, p2->name)==0){
3222 if(p->decode) decode=1;
3223 if(p->encode) encode=1;
3224 cap |= p->capabilities;
3229 last_name= p2->name;
3232 case CODEC_TYPE_VIDEO:
3235 case CODEC_TYPE_AUDIO:
3238 case CODEC_TYPE_SUBTITLE:
3247 decode ? "D": (/*p2->decoder ? "d":*/" "),
3250 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3251 cap & CODEC_CAP_DR1 ? "D":" ",
3252 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3254 /* if(p2->decoder && decode==0)
3255 printf(" use %s for decoding", p2->decoder->name);*/
3260 printf("Supported file protocols:\n");
3261 for(up = first_protocol; up != NULL; up = up->next)
3262 printf(" %s:", up->name);
3265 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3266 printf("Motion estimation methods:\n");
3270 if ((pp - motion_str + 1) == ME_ZERO)
3271 printf("(fastest)");
3272 else if ((pp - motion_str + 1) == ME_FULL)
3273 printf("(slowest)");
3274 else if ((pp - motion_str + 1) == ME_EPZS)
3275 printf("(default)");
3280 "Note, the names of encoders and decoders dont always match, so there are\n"
3281 "several cases where the above table shows encoder only or decoder only entries\n"
3282 "even though both encoding and decoding are supported for example, the h263\n"
3283 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3288 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3291 const char *p = str;
3298 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3305 static void opt_inter_matrix(const char *arg)
3307 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3308 parse_matrix_coeffs(inter_matrix, arg);
3311 static void opt_intra_matrix(const char *arg)
3313 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3314 parse_matrix_coeffs(intra_matrix, arg);
3317 static void opt_target(const char *arg)
3320 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3322 if(!strncmp(arg, "pal-", 4)) {
3325 } else if(!strncmp(arg, "ntsc-", 5)) {
3328 } else if(!strncmp(arg, "film-", 5)) {
3333 /* Calculate FR via float to avoid int overflow */
3334 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3337 } else if((fr == 29970) || (fr == 23976)) {
3340 /* Try to determine PAL/NTSC by peeking in the input files */
3341 if(nb_input_files) {
3343 for(j = 0; j < nb_input_files; j++) {
3344 for(i = 0; i < input_files[j]->nb_streams; i++) {
3345 AVCodecContext *c = input_files[j]->streams[i]->codec;
3346 if(c->codec_type != CODEC_TYPE_VIDEO)
3348 fr = c->time_base.den * 1000 / c->time_base.num;
3352 } else if((fr == 29970) || (fr == 23976)) {
3362 if(verbose && norm >= 0)
3363 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3367 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3368 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3369 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3373 if(!strcmp(arg, "vcd")) {
3375 opt_video_codec("mpeg1video");
3376 opt_audio_codec("mp2");
3379 opt_frame_size(norm ? "352x240" : "352x288");
3380 opt_frame_rate(frame_rates[norm]);
3381 opt_default("gop", norm ? "18" : "15");
3383 opt_default("b", "1150000");
3384 opt_default("maxrate", "1150000");
3385 opt_default("minrate", "1150000");
3386 opt_default("bufsize", "327680"); // 40*1024*8;
3388 opt_default("ab", "224000");
3389 audio_sample_rate = 44100;
3392 opt_default("packetsize", "2324");
3393 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3395 /* We have to offset the PTS, so that it is consistent with the SCR.
3396 SCR starts at 36000, but the first two packs contain only padding
3397 and the first pack from the other stream, respectively, may also have
3398 been written before.
3399 So the real data starts at SCR 36000+3*1200. */
3400 mux_preload= (36000+3*1200) / 90000.0; //0.44
3401 } else if(!strcmp(arg, "svcd")) {
3403 opt_video_codec("mpeg2video");
3404 opt_audio_codec("mp2");
3407 opt_frame_size(norm ? "480x480" : "480x576");
3408 opt_frame_rate(frame_rates[norm]);
3409 opt_default("gop", norm ? "18" : "15");
3411 opt_default("b", "2040000");
3412 opt_default("maxrate", "2516000");
3413 opt_default("minrate", "0"); //1145000;
3414 opt_default("bufsize", "1835008"); //224*1024*8;
3415 opt_default("flags", "+SCAN_OFFSET");
3418 opt_default("ab", "224000");
3419 audio_sample_rate = 44100;
3421 opt_default("packetsize", "2324");
3423 } else if(!strcmp(arg, "dvd")) {
3425 opt_video_codec("mpeg2video");
3426 opt_audio_codec("ac3");
3429 opt_frame_size(norm ? "720x480" : "720x576");
3430 opt_frame_rate(frame_rates[norm]);
3431 opt_default("gop", norm ? "18" : "15");
3433 opt_default("b", "6000000");
3434 opt_default("maxrate", "9000000");
3435 opt_default("minrate", "0"); //1500000;
3436 opt_default("bufsize", "1835008"); //224*1024*8;
3438 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3439 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3441 opt_default("ab", "448000");
3442 audio_sample_rate = 48000;
3444 } else if(!strncmp(arg, "dv", 2)) {
3448 opt_frame_size(norm ? "720x480" : "720x576");
3449 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3450 (norm ? "yuv411p" : "yuv420p"));
3451 opt_frame_rate(frame_rates[norm]);
3453 audio_sample_rate = 48000;
3457 fprintf(stderr, "Unknown target: %s\n", arg);
3462 static void opt_video_bsf(const char *arg)
3464 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3465 AVBitStreamFilterContext **bsfp;
3468 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3472 bsfp= &video_bitstream_filters;
3474 bsfp= &(*bsfp)->next;
3479 //FIXME avoid audio - video code duplication
3480 static void opt_audio_bsf(const char *arg)
3482 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3483 AVBitStreamFilterContext **bsfp;
3486 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3490 bsfp= &audio_bitstream_filters;
3492 bsfp= &(*bsfp)->next;
3497 static void show_version(void)
3499 /* TODO: add function interface to avutil and avformat */
3500 fprintf(stderr, "ffmpeg " FFMPEG_VERSION "\n"
3504 LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3508 static int opt_default(const char *opt, const char *arg){
3511 for(type=0; type<CODEC_TYPE_NB; type++)
3512 o = av_set_string(avctx_opts[type], opt, arg);
3514 o = av_set_string(avformat_opts, opt, arg);
3517 o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
3518 else if(opt[0] == 'v')
3519 o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
3520 else if(opt[0] == 's')
3521 o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
3526 // 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));
3528 //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3529 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3530 opt_names[opt_name_count++]= o->name;
3532 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3533 /* disable generate of real time pts in ffm (need to be supressed anyway) */
3534 if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)
3538 if(avctx_opts[0]->debug)
3539 av_log_level = AV_LOG_DEBUG;
3543 const OptionDef options[] = {
3545 { "L", 0, {(void*)show_license}, "show license" },
3546 { "h", 0, {(void*)show_help}, "show help" },
3547 { "version", 0, {(void*)show_version}, "show version" },
3548 { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3549 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3550 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3551 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3552 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3553 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3554 { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3555 { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
3556 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3557 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3558 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3559 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3560 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3561 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3562 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3563 { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3564 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3565 "add timings for benchmarking" },
3566 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3567 "dump each input packet" },
3568 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3569 "when dumping packets, also dump the payload" },
3570 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3571 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3572 { "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)", "" },
3573 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3574 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3575 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3576 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3577 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3578 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3579 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3580 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3581 { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3584 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3585 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3586 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3587 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3588 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3589 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3590 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3591 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3592 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3593 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3594 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3595 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3596 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3597 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3598 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3599 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3600 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3601 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3602 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3603 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
3604 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3605 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3606 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3607 { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3609 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
3610 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3611 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3612 "use same video quality as source (implies VBR)" },
3613 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3614 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3615 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3616 "deinterlace pictures" },
3617 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3618 { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
3619 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3620 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3621 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3622 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3623 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3624 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3625 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3626 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3629 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3630 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3631 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3632 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3633 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3634 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3635 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3636 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3637 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3638 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3640 /* subtitle options */
3641 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3642 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3643 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3646 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3647 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3648 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3651 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3652 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3654 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
3655 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
3657 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3661 static void show_banner(void)
3663 fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2007 Fabrice Bellard, et al.\n");
3664 fprintf(stderr, " configuration: " FFMPEG_CONFIGURATION "\n");
3665 fprintf(stderr, " libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
3666 fprintf(stderr, " libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
3667 fprintf(stderr, " libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
3668 fprintf(stderr, " built on " __DATE__ " " __TIME__);
3670 fprintf(stderr, ", gcc: " __VERSION__ "\n");
3672 fprintf(stderr, ", using a non-gcc compiler\n");
3676 static void show_license(void)
3681 "FFmpeg is free software; you can redistribute it and/or modify\n"
3682 "it under the terms of the GNU General Public License as published by\n"
3683 "the Free Software Foundation; either version 2 of the License, or\n"
3684 "(at your option) any later version.\n"
3686 "FFmpeg is distributed in the hope that it will be useful,\n"
3687 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3688 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
3689 "GNU General Public License for more details.\n"
3691 "You should have received a copy of the GNU General Public License\n"
3692 "along with FFmpeg; if not, write to the Free Software\n"
3693 "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
3697 "FFmpeg is free software; you can redistribute it and/or\n"
3698 "modify it under the terms of the GNU Lesser General Public\n"
3699 "License as published by the Free Software Foundation; either\n"
3700 "version 2.1 of the License, or (at your option) any later version.\n"
3702 "FFmpeg is distributed in the hope that it will be useful,\n"
3703 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3704 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
3705 "Lesser General Public License for more details.\n"
3707 "You should have received a copy of the GNU Lesser General Public\n"
3708 "License along with FFmpeg; if not, write to the Free Software\n"
3709 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
3715 static void show_help(void)
3718 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3719 "Hyper fast Audio and Video encoder\n");
3721 show_help_options(options, "Main options:\n",
3722 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3723 show_help_options(options, "\nVideo options:\n",
3724 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3726 show_help_options(options, "\nAdvanced Video options:\n",
3727 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3728 OPT_VIDEO | OPT_EXPERT);
3729 show_help_options(options, "\nAudio options:\n",
3730 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3732 show_help_options(options, "\nAdvanced Audio options:\n",
3733 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3734 OPT_AUDIO | OPT_EXPERT);
3735 show_help_options(options, "\nSubtitle options:\n",
3736 OPT_SUBTITLE | OPT_GRAB,
3738 show_help_options(options, "\nAudio/Video grab options:\n",
3741 show_help_options(options, "\nAdvanced options:\n",
3742 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3744 av_opt_show(avctx_opts[0], NULL);
3745 av_opt_show(avformat_opts, NULL);
3750 void parse_arg_file(const char *filename)
3752 opt_output_file(filename);
3755 int main(int argc, char **argv)
3762 for(i=0; i<CODEC_TYPE_NB; i++)
3763 avctx_opts[i]= avcodec_alloc_context();
3764 avformat_opts = av_alloc_format_context();
3772 parse_options(argc, argv, options);
3774 /* file converter / grab */
3775 if (nb_output_files <= 0) {
3776 fprintf(stderr, "Must supply at least one output file\n");
3780 if (nb_input_files == 0) {
3781 fprintf(stderr, "Must supply at least one input file\n");
3786 av_encode(output_files, nb_output_files, input_files, nb_input_files,
3787 stream_maps, nb_stream_maps);
3788 ti = getutime() - ti;
3790 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3794 for(i=0;i<nb_output_files;i++) {
3795 /* maybe av_close_output_file ??? */
3796 AVFormatContext *s = output_files[i];
3798 if (!(s->oformat->flags & AVFMT_NOFILE))
3800 for(j=0;j<s->nb_streams;j++) {
3801 av_free(s->streams[j]->codec);
3802 av_free(s->streams[j]);
3806 for(i=0;i<nb_input_files;i++)
3807 av_close_input_file(input_files[i]);
3811 av_free(intra_matrix);
3812 av_free(inter_matrix);
3815 #ifdef CONFIG_POWERPC_PERF
3816 extern void powerpc_display_perf_report(void);
3817 powerpc_display_perf_report();
3818 #endif /* CONFIG_POWERPC_PERF */
3820 if (received_sigterm) {
3822 "Received signal %d: terminating.\n",
3823 (int) received_sigterm);
3827 exit(0); /* not all OS-es handle main() return value */