3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 #define HAVE_AV_CONFIG_H
26 #include "framehook.h"
35 #include <sys/ioctl.h>
38 #include <sys/resource.h>
41 #include <sys/types.h>
42 #include <sys/select.h>
45 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
54 #if !defined(INFINITY) && defined(HUGE_VAL)
55 #define INFINITY HUGE_VAL
60 /* select an input stream for an output stream */
61 typedef struct AVStreamMap {
65 int sync_stream_index;
68 /** select an input file for an output file */
69 typedef struct AVMetaDataMap {
74 extern const OptionDef options[];
76 static void show_help(void);
77 static void show_license(void);
78 static int opt_default(const char *opt, const char *arg);
82 static AVFormatContext *input_files[MAX_FILES];
83 static int64_t input_files_ts_offset[MAX_FILES];
84 static int nb_input_files = 0;
86 static AVFormatContext *output_files[MAX_FILES];
87 static int nb_output_files = 0;
89 static AVStreamMap stream_maps[MAX_FILES];
90 static int nb_stream_maps;
92 static AVMetaDataMap meta_data_maps[MAX_FILES];
93 static int nb_meta_data_maps;
95 static AVInputFormat *file_iformat;
96 static AVOutputFormat *file_oformat;
97 static int frame_width = 0;
98 static int frame_height = 0;
99 static float frame_aspect_ratio = 0;
100 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
101 static int frame_padtop = 0;
102 static int frame_padbottom = 0;
103 static int frame_padleft = 0;
104 static int frame_padright = 0;
105 static int padcolor[3] = {16,128,128}; /* default to black */
106 static int frame_topBand = 0;
107 static int frame_bottomBand = 0;
108 static int frame_leftBand = 0;
109 static int frame_rightBand = 0;
110 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
111 static int frame_rate = 25;
112 static int frame_rate_base = 1;
113 static float video_qscale = 0;
114 static int video_qdiff = 3;
115 static uint16_t *intra_matrix = NULL;
116 static uint16_t *inter_matrix = NULL;
117 #if 0 //experimental, (can be removed)
118 static float video_rc_qsquish=1.0;
119 static float video_rc_qmod_amp=0;
120 static int video_rc_qmod_freq=0;
122 static char *video_rc_override_string=NULL;
123 static char *video_rc_eq="tex^qComp";
124 static int me_method = ME_EPZS;
125 static int video_disable = 0;
126 static int video_discard = 0;
127 static int video_codec_id = CODEC_ID_NONE;
128 static int video_codec_tag = 0;
129 static int same_quality = 0;
130 static int do_deinterlace = 0;
131 static int strict = 0;
132 static int top_field_first = -1;
133 static int me_threshold = 0;
134 static int intra_dc_precision = 8;
135 static int loop_input = 0;
136 static int loop_output = AVFMT_NOOUTPUTLOOP;
137 static int qp_hist = 0;
139 static int intra_only = 0;
140 static int audio_sample_rate = 44100;
141 #define QSCALE_NONE -99999
142 static float audio_qscale = QSCALE_NONE;
143 static int audio_disable = 0;
144 static int audio_channels = 1;
145 static int audio_codec_id = CODEC_ID_NONE;
146 static int audio_codec_tag = 0;
147 static char *audio_language = NULL;
149 static int subtitle_codec_id = CODEC_ID_NONE;
150 static char *subtitle_language = NULL;
152 static float mux_preload= 0.5;
153 static float mux_max_delay= 0.7;
155 static int64_t recording_time = 0;
156 static int64_t start_time = 0;
157 static int64_t rec_timestamp = 0;
158 static int64_t input_ts_offset = 0;
159 static int file_overwrite = 0;
160 static char *str_title = NULL;
161 static char *str_author = NULL;
162 static char *str_copyright = NULL;
163 static char *str_comment = NULL;
164 static char *str_album = NULL;
165 static int do_benchmark = 0;
166 static int do_hex_dump = 0;
167 static int do_pkt_dump = 0;
168 static int do_psnr = 0;
169 static int do_vstats = 0;
170 static int do_pass = 0;
171 static char *pass_logfilename = NULL;
172 static int audio_stream_copy = 0;
173 static int video_stream_copy = 0;
174 static int subtitle_stream_copy = 0;
175 static int video_sync_method= 1;
176 static int audio_sync_method= 0;
177 static int copy_ts= 0;
178 static int opt_shortest = 0; //
179 static int video_global_header = 0;
181 static int rate_emu = 0;
183 static int video_channel = 0;
184 static char *video_standard = "ntsc";
186 static int audio_volume = 256;
188 static int using_stdin = 0;
189 static int using_vhook = 0;
190 static int verbose = 1;
191 static int thread_count= 1;
192 static int q_pressed = 0;
193 static int64_t video_size = 0;
194 static int64_t audio_size = 0;
195 static int64_t extra_size = 0;
196 static int nb_frames_dup = 0;
197 static int nb_frames_drop = 0;
198 static int input_sync;
199 static uint64_t limit_filesize = 0; //
201 static int pgmyuv_compatibility_hack=0;
202 static int dts_delta_threshold = 10;
204 static int sws_flags = SWS_BICUBIC;
206 const char **opt_names=NULL;
207 int opt_name_count=0;
208 AVCodecContext *avctx_opts[CODEC_TYPE_NB];
209 AVFormatContext *avformat_opts;
210 static int64_t timer_start = 0;
212 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
213 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
214 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
216 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
218 struct AVInputStream;
220 typedef struct AVOutputStream {
221 int file_index; /* file index */
222 int index; /* stream index in the output file */
223 int source_index; /* AVInputStream index */
224 AVStream *st; /* stream in the output file */
225 int encoding_needed; /* true if encoding needed for this stream */
227 /* input pts and corresponding output pts
229 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
230 struct AVInputStream *sync_ist; /* input stream to sync against */
231 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
234 AVFrame pict_tmp; /* temporary image for resampling */
235 struct SwsContext *img_resample_ctx; /* for image resampling */
239 int topBand; /* cropping area sizes */
243 int padtop; /* padding area sizes */
250 ReSampleContext *resample; /* for audio resampling */
251 AVFifoBuffer fifo; /* for compression: one audio fifo per codec */
255 typedef struct AVInputStream {
259 int discard; /* true if stream data should be discarded */
260 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
261 int64_t sample_index; /* current sample */
263 int64_t start; /* time when read started */
264 unsigned long frame; /* current frame */
265 int64_t next_pts; /* synthetic pts for cases where pkt.pts
267 int64_t pts; /* current pts */
268 int is_start; /* is 1 at the start and after a discontinuity */
271 typedef struct AVInputFile {
272 int eof_reached; /* true if eof reached */
273 int ist_index; /* index of first stream in ist_table */
274 int buffer_size; /* current total buffer size */
275 int nb_streams; /* nb streams we are aware of */
280 /* init terminal so that we can grab keys */
281 static struct termios oldtty;
284 static void term_exit(void)
287 tcsetattr (0, TCSANOW, &oldtty);
291 static volatile sig_atomic_t received_sigterm = 0;
294 sigterm_handler(int sig)
296 received_sigterm = sig;
300 static void term_init(void)
308 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
309 |INLCR|IGNCR|ICRNL|IXON);
310 tty.c_oflag |= OPOST;
311 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
312 tty.c_cflag &= ~(CSIZE|PARENB);
317 tcsetattr (0, TCSANOW, &tty);
318 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
321 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
322 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
324 register a function to be called at normal program termination
327 #ifdef CONFIG_BEOS_NETSERVER
328 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
332 /* read a key without blocking */
333 static int read_key(void)
341 #ifndef CONFIG_BEOS_NETSERVER
349 n = select(1, &rfds, NULL, NULL, &tv);
362 static int decode_interrupt_cb(void)
364 return q_pressed || (q_pressed = read_key() == 'q');
367 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
372 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
375 /* copy stream format */
376 s->nb_streams = ic->nb_streams;
377 for(i=0;i<ic->nb_streams;i++) {
380 // FIXME: a more elegant solution is needed
381 st = av_mallocz(sizeof(AVStream));
382 memcpy(st, ic->streams[i], sizeof(AVStream));
383 st->codec = avcodec_alloc_context();
384 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
388 av_close_input_file(ic);
393 get_sync_ipts(const AVOutputStream *ost)
395 const AVInputStream *ist = ost->sync_ist;
396 return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
399 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
401 AVPacket new_pkt= *pkt;
402 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
403 &new_pkt.data, &new_pkt.size,
404 pkt->data, pkt->size,
405 pkt->flags & PKT_FLAG_KEY);
408 new_pkt.destruct= av_destruct_packet;
415 av_interleaved_write_frame(s, pkt);
418 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
420 static void do_audio_out(AVFormatContext *s,
423 unsigned char *buf, int size)
426 static uint8_t *audio_buf = NULL;
427 static uint8_t *audio_out = NULL;
428 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
430 int size_out, frame_bytes, ret;
431 AVCodecContext *enc= ost->st->codec;
433 /* SC: dynamic allocation of buffers */
435 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
437 audio_out = av_malloc(audio_out_size);
438 if (!audio_buf || !audio_out)
439 return; /* Should signal an error ! */
441 if(audio_sync_method){
442 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
443 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
444 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
445 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
447 //FIXME resample delay
448 if(fabs(delta) > 50){
451 byte_delta= FFMAX(byte_delta, -size);
455 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
460 static uint8_t *input_tmp= NULL;
461 input_tmp= av_realloc(input_tmp, byte_delta + size);
463 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
466 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
468 memset(input_tmp, 0, byte_delta);
469 memcpy(input_tmp + byte_delta, buf, size);
473 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
475 }else if(audio_sync_method>1){
476 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
477 assert(ost->audio_resample);
479 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
480 // fprintf(stderr, "drift:%f len:%d opts:%"PRId64" ipts:%"PRId64" fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2));
481 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
485 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
486 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
488 if (ost->audio_resample) {
490 size_out = audio_resample(ost->resample,
491 (short *)buftmp, (short *)buf,
492 size / (ist->st->codec->channels * 2));
493 size_out = size_out * enc->channels * 2;
499 /* now encode as many frames as possible */
500 if (enc->frame_size > 1) {
501 /* output resampled raw samples */
502 av_fifo_write(&ost->fifo, buftmp, size_out);
504 frame_bytes = enc->frame_size * 2 * enc->channels;
506 while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
508 av_init_packet(&pkt);
510 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
513 pkt.stream_index= ost->index;
516 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
517 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
518 pkt.flags |= PKT_FLAG_KEY;
519 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
521 ost->sync_opts += enc->frame_size;
525 av_init_packet(&pkt);
527 ost->sync_opts += size_out / (2 * enc->channels);
529 /* output a pcm frame */
530 /* XXX: change encoding codec API to avoid this ? */
531 switch(enc->codec->id) {
532 case CODEC_ID_PCM_S32LE:
533 case CODEC_ID_PCM_S32BE:
534 case CODEC_ID_PCM_U32LE:
535 case CODEC_ID_PCM_U32BE:
536 size_out = size_out << 1;
538 case CODEC_ID_PCM_S24LE:
539 case CODEC_ID_PCM_S24BE:
540 case CODEC_ID_PCM_U24LE:
541 case CODEC_ID_PCM_U24BE:
542 case CODEC_ID_PCM_S24DAUD:
543 size_out = size_out / 2 * 3;
545 case CODEC_ID_PCM_S16LE:
546 case CODEC_ID_PCM_S16BE:
547 case CODEC_ID_PCM_U16LE:
548 case CODEC_ID_PCM_U16BE:
551 size_out = size_out >> 1;
554 ret = avcodec_encode_audio(enc, audio_out, size_out,
557 pkt.stream_index= ost->index;
560 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
561 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
562 pkt.flags |= PKT_FLAG_KEY;
563 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
567 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
571 AVPicture picture_tmp;
574 dec = ist->st->codec;
576 /* deinterlace : must be done before any resize */
577 if (do_deinterlace || using_vhook) {
580 /* create temporary picture */
581 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
582 buf = av_malloc(size);
586 picture2 = &picture_tmp;
587 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
590 if(avpicture_deinterlace(picture2, picture,
591 dec->pix_fmt, dec->width, dec->height) < 0) {
592 /* if error, do not deinterlace */
598 av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
604 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
605 1000000 * ist->pts / AV_TIME_BASE);
607 if (picture != picture2)
608 *picture = *picture2;
612 /* we begin to correct av delay at this threshold */
613 #define AV_DELAY_MAX 0.100
615 static void do_subtitle_out(AVFormatContext *s,
621 static uint8_t *subtitle_out = NULL;
622 int subtitle_out_max_size = 65536;
623 int subtitle_out_size, nb, i;
627 if (pts == AV_NOPTS_VALUE) {
628 fprintf(stderr, "Subtitle packets must have a pts\n");
632 enc = ost->st->codec;
635 subtitle_out = av_malloc(subtitle_out_max_size);
638 /* Note: DVB subtitle need one packet to draw them and one other
639 packet to clear them */
640 /* XXX: signal it in the codec context ? */
641 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
646 for(i = 0; i < nb; i++) {
647 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
648 subtitle_out_max_size, sub);
650 av_init_packet(&pkt);
651 pkt.stream_index = ost->index;
652 pkt.data = subtitle_out;
653 pkt.size = subtitle_out_size;
654 pkt.pts = av_rescale_q(av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
655 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
656 /* XXX: the pts correction is handled here. Maybe handling
657 it in the codec would be better */
659 pkt.pts += 90 * sub->start_display_time;
661 pkt.pts += 90 * sub->end_display_time;
663 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
667 static int bit_buffer_size= 1024*256;
668 static uint8_t *bit_buffer= NULL;
670 static void do_video_out(AVFormatContext *s,
676 int nb_frames, i, ret;
677 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
678 AVFrame picture_crop_temp, picture_pad_temp;
679 AVCodecContext *enc, *dec;
681 avcodec_get_frame_defaults(&picture_crop_temp);
682 avcodec_get_frame_defaults(&picture_pad_temp);
684 enc = ost->st->codec;
685 dec = ist->st->codec;
687 /* by default, we output a single frame */
692 if(video_sync_method){
694 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
695 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
698 else if (vdelta > 1.1)
699 nb_frames = lrintf(vdelta);
700 //fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, ost->sync_ipts, nb_frames);
704 fprintf(stderr, "*** drop!\n");
705 }else if (nb_frames > 1) {
706 nb_frames_dup += nb_frames;
708 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
711 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
713 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
717 if (ost->video_crop) {
718 if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
719 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
722 formatted_picture = &picture_crop_temp;
724 formatted_picture = in_picture;
727 final_picture = formatted_picture;
728 padding_src = formatted_picture;
729 resampling_dst = &ost->pict_tmp;
730 if (ost->video_pad) {
731 final_picture = &ost->pict_tmp;
732 if (ost->video_resample) {
733 if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
734 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
737 resampling_dst = &picture_pad_temp;
741 if (ost->video_resample) {
743 final_picture = &ost->pict_tmp;
744 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
745 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
748 if (ost->video_pad) {
749 av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
750 enc->height, enc->width, enc->pix_fmt,
751 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
754 /* duplicates frame if needed */
755 for(i=0;i<nb_frames;i++) {
757 av_init_packet(&pkt);
758 pkt.stream_index= ost->index;
760 if (s->oformat->flags & AVFMT_RAWPICTURE) {
761 /* raw pictures are written as AVPicture structure to
762 avoid any copies. We support temorarily the older
764 AVFrame* old_frame = enc->coded_frame;
765 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
766 pkt.data= (uint8_t *)final_picture;
767 pkt.size= sizeof(AVPicture);
768 if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
769 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
770 if(dec->coded_frame && dec->coded_frame->key_frame)
771 pkt.flags |= PKT_FLAG_KEY;
773 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
774 enc->coded_frame = old_frame;
778 big_picture= *final_picture;
779 /* better than nothing: use input picture interlaced
781 big_picture.interlaced_frame = in_picture->interlaced_frame;
782 if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
783 if(top_field_first == -1)
784 big_picture.top_field_first = in_picture->top_field_first;
786 big_picture.top_field_first = top_field_first;
789 /* handles sameq here. This is not correct because it may
790 not be a global option */
792 big_picture.quality = ist->st->quality;
794 big_picture.quality = ost->st->quality;
796 big_picture.pict_type = 0;
797 // big_picture.pts = AV_NOPTS_VALUE;
798 big_picture.pts= ost->sync_opts;
799 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
800 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
801 ret = avcodec_encode_video(enc,
802 bit_buffer, bit_buffer_size,
805 fprintf(stderr, "Video encoding failed\n");
808 //enc->frame_number = enc->real_pict_num;
810 pkt.data= bit_buffer;
812 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
813 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
814 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
815 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
816 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
818 if(enc->coded_frame && enc->coded_frame->key_frame)
819 pkt.flags |= PKT_FLAG_KEY;
820 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
822 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
823 // enc->frame_number-1, enc->real_pict_num, ret,
825 /* if two pass, output log */
826 if (ost->logfile && enc->stats_out) {
827 fprintf(ost->logfile, "%s", enc->stats_out);
836 static double psnr(double d){
837 if(d==0) return INFINITY;
838 return -10.0*log(d)/log(10.0);
841 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
844 static FILE *fvstats=NULL;
851 double ti1, bitrate, avg_bitrate;
855 today = localtime(&today2);
856 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
859 fvstats = fopen(filename,"w");
867 enc = ost->st->codec;
868 if (enc->codec_type == CODEC_TYPE_VIDEO) {
869 frame_number = ost->frame_number;
870 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
871 if (enc->flags&CODEC_FLAG_PSNR)
872 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
874 fprintf(fvstats,"f_size= %6d ", frame_size);
875 /* compute pts value */
876 ti1 = ost->sync_opts * av_q2d(enc->time_base);
880 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
881 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
882 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
883 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
884 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
888 static void print_report(AVFormatContext **output_files,
889 AVOutputStream **ost_table, int nb_ostreams,
894 AVFormatContext *oc, *os;
897 int frame_number, vid, i;
898 double bitrate, ti1, pts;
899 static int64_t last_time = -1;
900 static int qp_histogram[52];
902 if (!is_last_report) {
904 /* display the report every 0.5 seconds */
905 cur_time = av_gettime();
906 if (last_time == -1) {
907 last_time = cur_time;
910 if ((cur_time - last_time) < 500000)
912 last_time = cur_time;
916 oc = output_files[0];
918 total_size = url_ftell(&oc->pb);
923 for(i=0;i<nb_ostreams;i++) {
925 os = output_files[ost->file_index];
926 enc = ost->st->codec;
927 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
928 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
929 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
931 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
932 float t = (av_gettime()-timer_start) / 1000000.0;
934 frame_number = ost->frame_number;
935 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
936 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
937 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*sizeof(*samples), 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;
1358 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1362 /* input stream init */
1364 for(i=0;i<nb_input_files;i++) {
1365 is = input_files[i];
1366 file_table[i].ist_index = j;
1367 file_table[i].nb_streams = is->nb_streams;
1368 j += is->nb_streams;
1372 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1376 for(i=0;i<nb_istreams;i++) {
1377 ist = av_mallocz(sizeof(AVInputStream));
1383 for(i=0;i<nb_input_files;i++) {
1384 is = input_files[i];
1385 for(k=0;k<is->nb_streams;k++) {
1386 ist = ist_table[j++];
1387 ist->st = is->streams[k];
1388 ist->file_index = i;
1390 ist->discard = 1; /* the stream is discarded by default
1393 if (ist->st->codec->rate_emu) {
1394 ist->start = av_gettime();
1400 /* output stream init */
1402 for(i=0;i<nb_output_files;i++) {
1403 os = output_files[i];
1404 if (!os->nb_streams) {
1405 fprintf(stderr, "Output file does not contain any stream\n");
1408 nb_ostreams += os->nb_streams;
1410 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1411 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1415 /* Sanity check the mapping args -- do the input files & streams exist? */
1416 for(i=0;i<nb_stream_maps;i++) {
1417 int fi = stream_maps[i].file_index;
1418 int si = stream_maps[i].stream_index;
1420 if (fi < 0 || fi > nb_input_files - 1 ||
1421 si < 0 || si > file_table[fi].nb_streams - 1) {
1422 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1425 fi = stream_maps[i].sync_file_index;
1426 si = stream_maps[i].sync_stream_index;
1427 if (fi < 0 || fi > nb_input_files - 1 ||
1428 si < 0 || si > file_table[fi].nb_streams - 1) {
1429 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1434 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1437 for(i=0;i<nb_ostreams;i++) {
1438 ost = av_mallocz(sizeof(AVOutputStream));
1445 for(k=0;k<nb_output_files;k++) {
1446 os = output_files[k];
1447 for(i=0;i<os->nb_streams;i++) {
1449 ost = ost_table[n++];
1450 ost->file_index = k;
1452 ost->st = os->streams[i];
1453 if (nb_stream_maps > 0) {
1454 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1455 stream_maps[n-1].stream_index;
1457 /* Sanity check that the stream types match */
1458 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1459 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1460 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1461 ost->file_index, ost->index);
1466 /* get corresponding input stream index : we select the first one with the right type */
1468 for(j=0;j<nb_istreams;j++) {
1471 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1472 ost->source_index = j;
1479 /* try again and reuse existing stream */
1480 for(j=0;j<nb_istreams;j++) {
1482 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1483 ost->source_index = j;
1488 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1489 ost->file_index, ost->index);
1494 ist = ist_table[ost->source_index];
1496 ost->sync_ist = (nb_stream_maps > 0) ?
1497 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1498 stream_maps[n-1].sync_stream_index] : ist;
1502 /* for each output stream, we compute the right encoding parameters */
1503 for(i=0;i<nb_ostreams;i++) {
1505 ist = ist_table[ost->source_index];
1507 codec = ost->st->codec;
1508 icodec = ist->st->codec;
1510 if (ost->st->stream_copy) {
1511 /* if stream_copy is selected, no need to decode or encode */
1512 codec->codec_id = icodec->codec_id;
1513 codec->codec_type = icodec->codec_type;
1514 if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1515 codec->bit_rate = icodec->bit_rate;
1516 codec->extradata= icodec->extradata;
1517 codec->extradata_size= icodec->extradata_size;
1518 if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1519 codec->time_base = icodec->time_base;
1521 codec->time_base = ist->st->time_base;
1522 switch(codec->codec_type) {
1523 case CODEC_TYPE_AUDIO:
1524 codec->sample_rate = icodec->sample_rate;
1525 codec->channels = icodec->channels;
1526 codec->frame_size = icodec->frame_size;
1527 codec->block_align= icodec->block_align;
1529 case CODEC_TYPE_VIDEO:
1531 fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1534 codec->pix_fmt = icodec->pix_fmt;
1535 codec->width = icodec->width;
1536 codec->height = icodec->height;
1537 codec->has_b_frames = icodec->has_b_frames;
1539 case CODEC_TYPE_SUBTITLE:
1545 switch(codec->codec_type) {
1546 case CODEC_TYPE_AUDIO:
1547 if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1550 if (codec->channels == icodec->channels &&
1551 codec->sample_rate == icodec->sample_rate) {
1552 ost->audio_resample = 0;
1554 if (codec->channels != icodec->channels &&
1555 (icodec->codec_id == CODEC_ID_AC3 ||
1556 icodec->codec_id == CODEC_ID_DTS)) {
1557 /* Special case for 5:1 AC3 and DTS input */
1558 /* and mono or stereo output */
1559 /* Request specific number of channels */
1560 icodec->channels = codec->channels;
1561 if (codec->sample_rate == icodec->sample_rate)
1562 ost->audio_resample = 0;
1564 ost->audio_resample = 1;
1567 ost->audio_resample = 1;
1570 if(audio_sync_method>1)
1571 ost->audio_resample = 1;
1573 if(ost->audio_resample){
1574 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1575 codec->sample_rate, icodec->sample_rate);
1577 printf("Can't resample. Aborting.\n");
1581 ist->decoding_needed = 1;
1582 ost->encoding_needed = 1;
1584 case CODEC_TYPE_VIDEO:
1585 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1586 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1587 ost->video_resample = ((codec->width != icodec->width -
1588 (frame_leftBand + frame_rightBand) +
1589 (frame_padleft + frame_padright)) ||
1590 (codec->height != icodec->height -
1591 (frame_topBand + frame_bottomBand) +
1592 (frame_padtop + frame_padbottom)) ||
1593 (codec->pix_fmt != icodec->pix_fmt));
1594 if (ost->video_crop) {
1595 ost->topBand = frame_topBand;
1596 ost->leftBand = frame_leftBand;
1598 if (ost->video_pad) {
1599 ost->padtop = frame_padtop;
1600 ost->padleft = frame_padleft;
1601 ost->padbottom = frame_padbottom;
1602 ost->padright = frame_padright;
1603 if (!ost->video_resample) {
1604 avcodec_get_frame_defaults(&ost->pict_tmp);
1605 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1606 codec->width, codec->height ) )
1610 if (ost->video_resample) {
1611 avcodec_get_frame_defaults(&ost->pict_tmp);
1612 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1613 codec->width, codec->height ) )
1616 ost->img_resample_ctx = sws_getContext(
1617 icodec->width - (frame_leftBand + frame_rightBand),
1618 icodec->height - (frame_topBand + frame_bottomBand),
1620 codec->width - (frame_padleft + frame_padright),
1621 codec->height - (frame_padtop + frame_padbottom),
1623 sws_flags, NULL, NULL, NULL);
1624 if (ost->img_resample_ctx == NULL) {
1625 fprintf(stderr, "Cannot get resampling context\n");
1628 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1630 ost->encoding_needed = 1;
1631 ist->decoding_needed = 1;
1633 case CODEC_TYPE_SUBTITLE:
1634 ost->encoding_needed = 1;
1635 ist->decoding_needed = 1;
1642 if (ost->encoding_needed &&
1643 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1644 char logfilename[1024];
1649 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1651 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1652 if (codec->flags & CODEC_FLAG_PASS1) {
1653 f = fopen(logfilename, "w");
1655 perror(logfilename);
1660 /* read the log file */
1661 f = fopen(logfilename, "r");
1663 perror(logfilename);
1666 fseek(f, 0, SEEK_END);
1668 fseek(f, 0, SEEK_SET);
1669 logbuffer = av_malloc(size + 1);
1671 fprintf(stderr, "Could not allocate log buffer\n");
1674 size = fread(logbuffer, 1, size, f);
1676 logbuffer[size] = '\0';
1677 codec->stats_in = logbuffer;
1681 if(codec->codec_type == CODEC_TYPE_VIDEO){
1682 int size= codec->width * codec->height;
1683 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1688 bit_buffer = av_malloc(bit_buffer_size);
1692 /* dump the file output parameters - cannot be done before in case
1694 for(i=0;i<nb_output_files;i++) {
1695 dump_format(output_files[i], i, output_files[i]->filename, 1);
1698 /* dump the stream mapping */
1700 fprintf(stderr, "Stream mapping:\n");
1701 for(i=0;i<nb_ostreams;i++) {
1703 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1704 ist_table[ost->source_index]->file_index,
1705 ist_table[ost->source_index]->index,
1708 if (ost->sync_ist != ist_table[ost->source_index])
1709 fprintf(stderr, " [sync #%d.%d]",
1710 ost->sync_ist->file_index,
1711 ost->sync_ist->index);
1712 fprintf(stderr, "\n");
1716 /* open each encoder */
1717 for(i=0;i<nb_ostreams;i++) {
1719 if (ost->encoding_needed) {
1721 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1723 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1724 ost->file_index, ost->index);
1727 if (avcodec_open(ost->st->codec, codec) < 0) {
1728 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1729 ost->file_index, ost->index);
1732 extra_size += ost->st->codec->extradata_size;
1736 /* open each decoder */
1737 for(i=0;i<nb_istreams;i++) {
1739 if (ist->decoding_needed) {
1741 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1743 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1744 ist->st->codec->codec_id, ist->file_index, ist->index);
1747 if (avcodec_open(ist->st->codec, codec) < 0) {
1748 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1749 ist->file_index, ist->index);
1752 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1753 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1758 for(i=0;i<nb_istreams;i++) {
1760 is = input_files[ist->file_index];
1762 ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1763 if(ist->st->start_time == AV_NOPTS_VALUE)
1765 if(input_files_ts_offset[ist->file_index])
1766 ist->next_pts= AV_NOPTS_VALUE;
1770 /* set meta data information from input file if required */
1771 for (i=0;i<nb_meta_data_maps;i++) {
1772 AVFormatContext *out_file;
1773 AVFormatContext *in_file;
1775 int out_file_index = meta_data_maps[i].out_file;
1776 int in_file_index = meta_data_maps[i].in_file;
1777 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1778 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1779 ret = AVERROR(EINVAL);
1782 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1783 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1784 ret = AVERROR(EINVAL);
1788 out_file = output_files[out_file_index];
1789 in_file = input_files[in_file_index];
1791 strcpy(out_file->title, in_file->title);
1792 strcpy(out_file->author, in_file->author);
1793 strcpy(out_file->copyright, in_file->copyright);
1794 strcpy(out_file->comment, in_file->comment);
1795 strcpy(out_file->album, in_file->album);
1796 out_file->year = in_file->year;
1797 out_file->track = in_file->track;
1798 strcpy(out_file->genre, in_file->genre);
1801 /* open files and write file headers */
1802 for(i=0;i<nb_output_files;i++) {
1803 os = output_files[i];
1804 if (av_write_header(os) < 0) {
1805 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1806 ret = AVERROR(EINVAL);
1811 if ( !using_stdin && verbose >= 0) {
1812 fprintf(stderr, "Press [q] to stop encoding\n");
1813 url_set_interrupt_cb(decode_interrupt_cb);
1818 timer_start = av_gettime();
1820 for(; received_sigterm == 0;) {
1821 int file_index, ist_index;
1829 /* if 'q' pressed, exits */
1833 /* read_key() returns 0 on EOF */
1839 /* select the stream that we must read now by looking at the
1840 smallest output pts */
1842 for(i=0;i<nb_ostreams;i++) {
1845 os = output_files[ost->file_index];
1846 ist = ist_table[ost->source_index];
1847 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1848 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1850 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1851 ipts = (double)ist->pts;
1852 if (!file_table[ist->file_index].eof_reached){
1853 if(ipts < ipts_min) {
1855 if(input_sync ) file_index = ist->file_index;
1857 if(opts < opts_min) {
1859 if(!input_sync) file_index = ist->file_index;
1862 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1867 /* if none, if is finished */
1868 if (file_index < 0) {
1872 /* finish if recording time exhausted */
1873 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1876 /* finish if limit size exhausted */
1877 if (limit_filesize != 0 && limit_filesize < url_ftell(&output_files[0]->pb))
1880 /* read a frame from it and output it in the fifo */
1881 is = input_files[file_index];
1882 if (av_read_frame(is, &pkt) < 0) {
1883 file_table[file_index].eof_reached = 1;
1884 if (opt_shortest) break; else continue; //
1888 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
1890 /* the following test is needed in case new streams appear
1891 dynamically in stream : we ignore them */
1892 if (pkt.stream_index >= file_table[file_index].nb_streams)
1893 goto discard_packet;
1894 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1895 ist = ist_table[ist_index];
1897 goto discard_packet;
1899 // 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);
1900 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1901 int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1902 if(FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1903 input_files_ts_offset[ist->file_index]-= delta;
1905 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1906 for(i=0; i<file_table[file_index].nb_streams; i++){
1907 int index= file_table[file_index].ist_index + i;
1908 ist_table[index]->next_pts += delta;
1909 ist_table[index]->is_start=1;
1914 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1915 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1918 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1919 ist->file_index, ist->index);
1921 av_free_packet(&pkt);
1926 av_free_packet(&pkt);
1928 /* dump report by using the output first video and audio streams */
1929 print_report(output_files, ost_table, nb_ostreams, 0);
1932 /* at the end of stream, we must flush the decoder buffers */
1933 for(i=0;i<nb_istreams;i++) {
1935 if (ist->decoding_needed) {
1936 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1942 /* write the trailer if needed and close file */
1943 for(i=0;i<nb_output_files;i++) {
1944 os = output_files[i];
1945 av_write_trailer(os);
1948 /* dump report by using the first video and audio streams */
1949 print_report(output_files, ost_table, nb_ostreams, 1);
1951 /* close each encoder */
1952 for(i=0;i<nb_ostreams;i++) {
1954 if (ost->encoding_needed) {
1955 av_freep(&ost->st->codec->stats_in);
1956 avcodec_close(ost->st->codec);
1960 /* close each decoder */
1961 for(i=0;i<nb_istreams;i++) {
1963 if (ist->decoding_needed) {
1964 avcodec_close(ist->st->codec);
1972 av_freep(&bit_buffer);
1973 av_free(file_table);
1976 for(i=0;i<nb_istreams;i++) {
1983 for(i=0;i<nb_ostreams;i++) {
1987 fclose(ost->logfile);
1988 ost->logfile = NULL;
1990 av_fifo_free(&ost->fifo); /* works even if fifo is not
1991 initialized but set to zero */
1992 av_free(ost->pict_tmp.data[0]);
1993 if (ost->video_resample)
1994 sws_freeContext(ost->img_resample_ctx);
1995 if (ost->audio_resample)
1996 audio_resample_close(ost->resample);
2004 ret = AVERROR(ENOMEM);
2009 int file_read(const char *filename)
2012 unsigned char buffer[1024];
2015 if (url_open(&h, filename, O_RDONLY) < 0) {
2016 printf("could not open '%s'\n", filename);
2020 len = url_read(h, buffer, sizeof(buffer));
2023 for(i=0;i<len;i++) putchar(buffer[i]);
2030 static void opt_format(const char *arg)
2032 /* compatibility stuff for pgmyuv */
2033 if (!strcmp(arg, "pgmyuv")) {
2034 pgmyuv_compatibility_hack=1;
2035 // opt_image_format(arg);
2037 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2040 file_iformat = av_find_input_format(arg);
2041 file_oformat = guess_format(arg, NULL, NULL);
2042 if (!file_iformat && !file_oformat) {
2043 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2048 static void opt_video_rc_eq(char *arg)
2053 static void opt_video_rc_override_string(char *arg)
2055 video_rc_override_string = arg;
2058 static void opt_me_threshold(const char *arg)
2060 me_threshold = atoi(arg);
2063 static void opt_verbose(const char *arg)
2065 verbose = atoi(arg);
2066 av_log_level = atoi(arg);
2069 static void opt_frame_rate(const char *arg)
2071 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2072 fprintf(stderr, "Incorrect frame rate\n");
2077 static void opt_frame_crop_top(const char *arg)
2079 frame_topBand = atoi(arg);
2080 if (frame_topBand < 0) {
2081 fprintf(stderr, "Incorrect top crop size\n");
2084 if ((frame_topBand % 2) != 0) {
2085 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2088 if ((frame_topBand) >= frame_height){
2089 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2092 frame_height -= frame_topBand;
2095 static void opt_frame_crop_bottom(const char *arg)
2097 frame_bottomBand = atoi(arg);
2098 if (frame_bottomBand < 0) {
2099 fprintf(stderr, "Incorrect bottom crop size\n");
2102 if ((frame_bottomBand % 2) != 0) {
2103 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2106 if ((frame_bottomBand) >= frame_height){
2107 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2110 frame_height -= frame_bottomBand;
2113 static void opt_frame_crop_left(const char *arg)
2115 frame_leftBand = atoi(arg);
2116 if (frame_leftBand < 0) {
2117 fprintf(stderr, "Incorrect left crop size\n");
2120 if ((frame_leftBand % 2) != 0) {
2121 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2124 if ((frame_leftBand) >= frame_width){
2125 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2128 frame_width -= frame_leftBand;
2131 static void opt_frame_crop_right(const char *arg)
2133 frame_rightBand = atoi(arg);
2134 if (frame_rightBand < 0) {
2135 fprintf(stderr, "Incorrect right crop size\n");
2138 if ((frame_rightBand % 2) != 0) {
2139 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2142 if ((frame_rightBand) >= frame_width){
2143 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2146 frame_width -= frame_rightBand;
2149 static void opt_frame_size(const char *arg)
2151 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2152 fprintf(stderr, "Incorrect frame size\n");
2155 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2156 fprintf(stderr, "Frame size must be a multiple of 2\n");
2162 #define SCALEBITS 10
2163 #define ONE_HALF (1 << (SCALEBITS - 1))
2164 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2166 #define RGB_TO_Y(r, g, b) \
2167 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2168 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2170 #define RGB_TO_U(r1, g1, b1, shift)\
2171 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2172 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2174 #define RGB_TO_V(r1, g1, b1, shift)\
2175 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2176 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2178 static void opt_pad_color(const char *arg) {
2179 /* Input is expected to be six hex digits similar to
2180 how colors are expressed in html tags (but without the #) */
2181 int rgb = strtol(arg, NULL, 16);
2185 g = ((rgb >> 8) & 255);
2188 padcolor[0] = RGB_TO_Y(r,g,b);
2189 padcolor[1] = RGB_TO_U(r,g,b,0);
2190 padcolor[2] = RGB_TO_V(r,g,b,0);
2193 static void opt_frame_pad_top(const char *arg)
2195 frame_padtop = atoi(arg);
2196 if (frame_padtop < 0) {
2197 fprintf(stderr, "Incorrect top pad size\n");
2200 if ((frame_padtop % 2) != 0) {
2201 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2206 static void opt_frame_pad_bottom(const char *arg)
2208 frame_padbottom = atoi(arg);
2209 if (frame_padbottom < 0) {
2210 fprintf(stderr, "Incorrect bottom pad size\n");
2213 if ((frame_padbottom % 2) != 0) {
2214 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2220 static void opt_frame_pad_left(const char *arg)
2222 frame_padleft = atoi(arg);
2223 if (frame_padleft < 0) {
2224 fprintf(stderr, "Incorrect left pad size\n");
2227 if ((frame_padleft % 2) != 0) {
2228 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2234 static void opt_frame_pad_right(const char *arg)
2236 frame_padright = atoi(arg);
2237 if (frame_padright < 0) {
2238 fprintf(stderr, "Incorrect right pad size\n");
2241 if ((frame_padright % 2) != 0) {
2242 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2248 static void opt_frame_pix_fmt(const char *arg)
2250 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2253 static void opt_frame_aspect_ratio(const char *arg)
2259 p = strchr(arg, ':');
2261 x = strtol(arg, (char **)&arg, 10);
2263 y = strtol(arg+1, (char **)&arg, 10);
2265 ar = (double)x / (double)y;
2267 ar = strtod(arg, (char **)&arg);
2270 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2273 frame_aspect_ratio = ar;
2276 static void opt_qscale(const char *arg)
2278 video_qscale = atof(arg);
2279 if (video_qscale <= 0 ||
2280 video_qscale > 255) {
2281 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2286 static void opt_qdiff(const char *arg)
2288 video_qdiff = atoi(arg);
2289 if (video_qdiff < 0 ||
2291 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2296 static void opt_strict(const char *arg)
2301 static void opt_top_field_first(const char *arg)
2303 top_field_first= atoi(arg);
2306 static void opt_thread_count(const char *arg)
2308 thread_count= atoi(arg);
2309 #if !defined(HAVE_THREADS)
2311 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2315 static void opt_audio_rate(const char *arg)
2317 audio_sample_rate = atoi(arg);
2320 static void opt_audio_channels(const char *arg)
2322 audio_channels = atoi(arg);
2325 static void opt_video_channel(const char *arg)
2327 video_channel = strtol(arg, NULL, 0);
2330 static void opt_video_standard(const char *arg)
2332 video_standard = av_strdup(arg);
2335 static void opt_codec(int *pstream_copy, int *pcodec_id,
2336 int codec_type, const char *arg)
2340 if (!strcmp(arg, "copy")) {
2345 if (!strcmp(p->name, arg) && p->type == codec_type)
2350 fprintf(stderr, "Unknown codec '%s'\n", arg);
2358 static void opt_audio_codec(const char *arg)
2360 opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2363 static void opt_audio_tag(const char *arg)
2366 audio_codec_tag= strtol(arg, &tail, 0);
2369 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2372 static void opt_video_tag(const char *arg)
2375 video_codec_tag= strtol(arg, &tail, 0);
2378 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2381 static void add_frame_hooker(const char *arg)
2386 char *args = av_strdup(arg);
2390 argv[0] = strtok(args, " ");
2391 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2394 i = frame_hook_add(argc, argv);
2397 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2402 const char *motion_str[] = {
2415 static void opt_motion_estimation(const char *arg)
2421 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2424 if (!strcmp(*p, arg))
2428 me_method = (p - motion_str) + 1;
2431 static void opt_video_codec(const char *arg)
2433 opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2436 static void opt_subtitle_codec(const char *arg)
2438 opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2441 static void opt_map(const char *arg)
2447 m = &stream_maps[nb_stream_maps++];
2449 m->file_index = strtol(arg, (char **)&p, 0);
2453 m->stream_index = strtol(p, (char **)&p, 0);
2456 m->sync_file_index = strtol(p, (char **)&p, 0);
2459 m->sync_stream_index = strtol(p, (char **)&p, 0);
2461 m->sync_file_index = m->file_index;
2462 m->sync_stream_index = m->stream_index;
2466 static void opt_map_meta_data(const char *arg)
2472 m = &meta_data_maps[nb_meta_data_maps++];
2474 m->out_file = strtol(arg, (char **)&p, 0);
2478 m->in_file = strtol(p, (char **)&p, 0);
2481 static void opt_recording_time(const char *arg)
2483 recording_time = parse_date(arg, 1);
2486 static void opt_start_time(const char *arg)
2488 start_time = parse_date(arg, 1);
2491 static void opt_rec_timestamp(const char *arg)
2493 rec_timestamp = parse_date(arg, 0) / 1000000;
2496 static void opt_input_ts_offset(const char *arg)
2498 input_ts_offset = parse_date(arg, 1);
2501 static void opt_input_file(const char *filename)
2503 AVFormatContext *ic;
2504 AVFormatParameters params, *ap = ¶ms;
2505 int err, i, ret, rfps, rfps_base;
2508 if (!strcmp(filename, "-"))
2511 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2512 !strcmp( filename, "/dev/stdin" );
2514 /* get default parameters from command line */
2515 ic = av_alloc_format_context();
2517 memset(ap, 0, sizeof(*ap));
2518 ap->prealloced_context = 1;
2519 ap->sample_rate = audio_sample_rate;
2520 ap->channels = audio_channels;
2521 ap->time_base.den = frame_rate;
2522 ap->time_base.num = frame_rate_base;
2523 ap->width = frame_width + frame_padleft + frame_padright;
2524 ap->height = frame_height + frame_padtop + frame_padbottom;
2525 ap->pix_fmt = frame_pix_fmt;
2526 ap->channel = video_channel;
2527 ap->standard = video_standard;
2528 ap->video_codec_id = video_codec_id;
2529 ap->audio_codec_id = audio_codec_id;
2530 if(pgmyuv_compatibility_hack)
2531 ap->video_codec_id= CODEC_ID_PGMYUV;
2533 for(i=0; i<opt_name_count; i++){
2534 const AVOption *opt;
2535 double d= av_get_double(avformat_opts, opt_names[i], &opt);
2536 if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2537 av_set_double(ic, opt_names[i], d);
2539 /* open the input file with generic libav function */
2540 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2542 print_error(filename, err);
2546 ic->loop_input = loop_input;
2548 /* If not enough info to get the stream parameters, we decode the
2549 first frames to get it. (used in mpeg case for example) */
2550 ret = av_find_stream_info(ic);
2551 if (ret < 0 && verbose >= 0) {
2552 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2556 timestamp = start_time;
2557 /* add the stream start time */
2558 if (ic->start_time != AV_NOPTS_VALUE)
2559 timestamp += ic->start_time;
2561 /* if seeking requested, we execute it */
2562 if (start_time != 0) {
2563 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2565 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2566 filename, (double)timestamp / AV_TIME_BASE);
2568 /* reset seek info */
2572 /* update the current parameters so that they match the one of the input stream */
2573 for(i=0;i<ic->nb_streams;i++) {
2575 AVCodecContext *enc = ic->streams[i]->codec;
2577 avcodec_thread_init(enc, thread_count);
2578 enc->thread_count= thread_count;
2579 switch(enc->codec_type) {
2580 case CODEC_TYPE_AUDIO:
2581 for(j=0; j<opt_name_count; j++){
2582 const AVOption *opt;
2583 double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt);
2584 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2585 av_set_double(enc, opt_names[j], d);
2587 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2588 audio_channels = enc->channels;
2589 audio_sample_rate = enc->sample_rate;
2591 ic->streams[i]->discard= AVDISCARD_ALL;
2593 case CODEC_TYPE_VIDEO:
2594 for(j=0; j<opt_name_count; j++){
2595 const AVOption *opt;
2596 double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt);
2597 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2598 av_set_double(enc, opt_names[j], d);
2600 frame_height = enc->height;
2601 frame_width = enc->width;
2602 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2603 frame_pix_fmt = enc->pix_fmt;
2604 rfps = ic->streams[i]->r_frame_rate.num;
2605 rfps_base = ic->streams[i]->r_frame_rate.den;
2606 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2608 enc->debug |= FF_DEBUG_MV;
2610 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2613 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2614 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2616 (float)rfps / rfps_base, rfps, rfps_base);
2618 /* update the current frame rate to match the stream frame rate */
2620 frame_rate_base = rfps_base;
2622 enc->rate_emu = rate_emu;
2624 ic->streams[i]->discard= AVDISCARD_ALL;
2625 else if(video_discard)
2626 ic->streams[i]->discard= video_discard;
2628 case CODEC_TYPE_DATA:
2630 case CODEC_TYPE_SUBTITLE:
2632 case CODEC_TYPE_UNKNOWN:
2639 input_files[nb_input_files] = ic;
2640 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2641 /* dump the file content */
2643 dump_format(ic, nb_input_files, filename, 0);
2646 file_iformat = NULL;
2647 file_oformat = NULL;
2654 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2656 int has_video, has_audio, i, j;
2657 AVFormatContext *ic;
2661 for(j=0;j<nb_input_files;j++) {
2662 ic = input_files[j];
2663 for(i=0;i<ic->nb_streams;i++) {
2664 AVCodecContext *enc = ic->streams[i]->codec;
2665 switch(enc->codec_type) {
2666 case CODEC_TYPE_AUDIO:
2669 case CODEC_TYPE_VIDEO:
2672 case CODEC_TYPE_DATA:
2673 case CODEC_TYPE_UNKNOWN:
2674 case CODEC_TYPE_SUBTITLE:
2681 *has_video_ptr = has_video;
2682 *has_audio_ptr = has_audio;
2685 static void new_video_stream(AVFormatContext *oc)
2688 AVCodecContext *video_enc;
2691 st = av_new_stream(oc, oc->nb_streams);
2693 fprintf(stderr, "Could not alloc stream\n");
2696 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2697 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2698 video_bitstream_filters= NULL;
2701 avcodec_thread_init(st->codec, thread_count);
2703 video_enc = st->codec;
2706 video_enc->codec_tag= video_codec_tag;
2708 if( (video_global_header&1)
2709 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2710 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2711 avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2713 if(video_global_header&2){
2714 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2715 avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2718 if (video_stream_copy) {
2719 st->stream_copy = 1;
2720 video_enc->codec_type = CODEC_TYPE_VIDEO;
2726 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2727 if (video_codec_id != CODEC_ID_NONE)
2728 codec_id = video_codec_id;
2730 video_enc->codec_id = codec_id;
2731 codec = avcodec_find_encoder(codec_id);
2733 for(i=0; i<opt_name_count; i++){
2734 const AVOption *opt;
2735 double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt);
2736 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2737 av_set_double(video_enc, opt_names[i], d);
2740 video_enc->time_base.den = frame_rate;
2741 video_enc->time_base.num = frame_rate_base;
2742 if(codec && codec->supported_framerates){
2743 const AVRational *p= codec->supported_framerates;
2744 AVRational req= (AVRational){frame_rate, frame_rate_base};
2745 const AVRational *best=NULL;
2746 AVRational best_error= (AVRational){INT_MAX, 1};
2747 for(; p->den!=0; p++){
2748 AVRational error= av_sub_q(req, *p);
2749 if(error.num <0) error.num *= -1;
2750 if(av_cmp_q(error, best_error) < 0){
2755 video_enc->time_base.den= best->num;
2756 video_enc->time_base.num= best->den;
2759 video_enc->width = frame_width + frame_padright + frame_padleft;
2760 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2761 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2762 video_enc->pix_fmt = frame_pix_fmt;
2764 if(codec && codec->pix_fmts){
2765 const enum PixelFormat *p= codec->pix_fmts;
2767 if(*p == video_enc->pix_fmt)
2771 video_enc->pix_fmt = codec->pix_fmts[0];
2775 video_enc->gop_size = 0;
2776 if (video_qscale || same_quality) {
2777 video_enc->flags |= CODEC_FLAG_QSCALE;
2778 video_enc->global_quality=
2779 st->quality = FF_QP2LAMBDA * video_qscale;
2783 video_enc->intra_matrix = intra_matrix;
2785 video_enc->inter_matrix = inter_matrix;
2787 video_enc->max_qdiff = video_qdiff;
2788 video_enc->rc_eq = video_rc_eq;
2789 video_enc->thread_count = thread_count;
2790 p= video_rc_override_string;
2793 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2795 fprintf(stderr, "error parsing rc_override\n");
2798 video_enc->rc_override=
2799 av_realloc(video_enc->rc_override,
2800 sizeof(RcOverride)*(i+1));
2801 video_enc->rc_override[i].start_frame= start;
2802 video_enc->rc_override[i].end_frame = end;
2804 video_enc->rc_override[i].qscale= q;
2805 video_enc->rc_override[i].quality_factor= 1.0;
2808 video_enc->rc_override[i].qscale= 0;
2809 video_enc->rc_override[i].quality_factor= -q/100.0;
2814 video_enc->rc_override_count=i;
2815 if (!video_enc->rc_initial_buffer_occupancy)
2816 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2817 video_enc->me_threshold= me_threshold;
2818 video_enc->intra_dc_precision= intra_dc_precision - 8;
2819 video_enc->strict_std_compliance = strict;
2822 video_enc->flags|= CODEC_FLAG_PSNR;
2824 video_enc->me_method = me_method;
2829 video_enc->flags |= CODEC_FLAG_PASS1;
2831 video_enc->flags |= CODEC_FLAG_PASS2;
2836 /* reset some key parameters */
2838 video_codec_id = CODEC_ID_NONE;
2839 video_stream_copy = 0;
2842 static void new_audio_stream(AVFormatContext *oc)
2845 AVCodecContext *audio_enc;
2848 st = av_new_stream(oc, oc->nb_streams);
2850 fprintf(stderr, "Could not alloc stream\n");
2853 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
2855 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2856 audio_bitstream_filters= NULL;
2859 avcodec_thread_init(st->codec, thread_count);
2861 audio_enc = st->codec;
2862 audio_enc->codec_type = CODEC_TYPE_AUDIO;
2863 audio_enc->strict_std_compliance = strict;
2866 audio_enc->codec_tag= audio_codec_tag;
2868 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2869 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2870 avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2872 if (audio_stream_copy) {
2873 st->stream_copy = 1;
2874 audio_enc->channels = audio_channels;
2876 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2878 for(i=0; i<opt_name_count; i++){
2879 const AVOption *opt;
2880 double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt);
2881 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2882 av_set_double(audio_enc, opt_names[i], d);
2885 if (audio_codec_id != CODEC_ID_NONE)
2886 codec_id = audio_codec_id;
2887 audio_enc->codec_id = codec_id;
2889 if (audio_qscale > QSCALE_NONE) {
2890 audio_enc->flags |= CODEC_FLAG_QSCALE;
2891 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
2893 audio_enc->thread_count = thread_count;
2894 audio_enc->channels = audio_channels;
2896 audio_enc->sample_rate = audio_sample_rate;
2897 audio_enc->time_base= (AVRational){1, audio_sample_rate};
2898 if (audio_language) {
2899 pstrcpy(st->language, sizeof(st->language), audio_language);
2900 av_free(audio_language);
2901 audio_language = NULL;
2904 /* reset some key parameters */
2906 audio_codec_id = CODEC_ID_NONE;
2907 audio_stream_copy = 0;
2910 static void opt_new_subtitle_stream(void)
2912 AVFormatContext *oc;
2914 AVCodecContext *subtitle_enc;
2917 if (nb_output_files <= 0) {
2918 fprintf(stderr, "At least one output file must be specified\n");
2921 oc = output_files[nb_output_files - 1];
2923 st = av_new_stream(oc, oc->nb_streams);
2925 fprintf(stderr, "Could not alloc stream\n");
2928 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
2930 subtitle_enc = st->codec;
2931 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
2932 if (subtitle_stream_copy) {
2933 st->stream_copy = 1;
2935 for(i=0; i<opt_name_count; i++){
2936 const AVOption *opt;
2937 double d= av_get_double(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt);
2938 if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2939 av_set_double(subtitle_enc, opt_names[i], d);
2941 subtitle_enc->codec_id = subtitle_codec_id;
2944 if (subtitle_language) {
2945 pstrcpy(st->language, sizeof(st->language), subtitle_language);
2946 av_free(subtitle_language);
2947 subtitle_language = NULL;
2950 subtitle_codec_id = CODEC_ID_NONE;
2951 subtitle_stream_copy = 0;
2954 static void opt_new_audio_stream(void)
2956 AVFormatContext *oc;
2957 if (nb_output_files <= 0) {
2958 fprintf(stderr, "At least one output file must be specified\n");
2961 oc = output_files[nb_output_files - 1];
2962 new_audio_stream(oc);
2965 static void opt_new_video_stream(void)
2967 AVFormatContext *oc;
2968 if (nb_output_files <= 0) {
2969 fprintf(stderr, "At least one output file must be specified\n");
2972 oc = output_files[nb_output_files - 1];
2973 new_video_stream(oc);
2976 static void opt_output_file(const char *filename)
2978 AVFormatContext *oc;
2979 int use_video, use_audio, input_has_video, input_has_audio, i;
2980 AVFormatParameters params, *ap = ¶ms;
2982 if (!strcmp(filename, "-"))
2985 oc = av_alloc_format_context();
2987 if (!file_oformat) {
2988 file_oformat = guess_format(NULL, filename, NULL);
2989 if (!file_oformat) {
2990 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
2996 oc->oformat = file_oformat;
2997 pstrcpy(oc->filename, sizeof(oc->filename), filename);
2999 if (!strcmp(file_oformat->name, "ffm") &&
3000 strstart(filename, "http:", NULL)) {
3001 /* special case for files sent to ffserver: we get the stream
3002 parameters from ffserver */
3003 if (read_ffserver_streams(oc, filename) < 0) {
3004 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3008 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3009 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3011 /* disable if no corresponding type found and at least one
3013 if (nb_input_files > 0) {
3014 check_audio_video_inputs(&input_has_video, &input_has_audio);
3015 if (!input_has_video)
3017 if (!input_has_audio)
3021 /* manual disable */
3022 if (audio_disable) {
3025 if (video_disable) {
3030 new_video_stream(oc);
3034 new_audio_stream(oc);
3037 oc->timestamp = rec_timestamp;
3040 pstrcpy(oc->title, sizeof(oc->title), str_title);
3042 pstrcpy(oc->author, sizeof(oc->author), str_author);
3044 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3046 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3048 pstrcpy(oc->album, sizeof(oc->album), str_album);
3051 output_files[nb_output_files++] = oc;
3053 /* check filename in case of an image number is expected */
3054 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3055 if (!av_filename_number_test(oc->filename)) {
3056 print_error(oc->filename, AVERROR_NUMEXPECTED);
3061 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3062 /* test if it already exists to avoid loosing precious files */
3063 if (!file_overwrite &&
3064 (strchr(filename, ':') == NULL ||
3065 strstart(filename, "file:", NULL))) {
3066 if (url_exist(filename)) {
3069 if ( !using_stdin ) {
3070 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3073 if (toupper(c) != 'Y') {
3074 fprintf(stderr, "Not overwriting - exiting\n");
3079 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3086 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3087 fprintf(stderr, "Could not open '%s'\n", filename);
3092 memset(ap, 0, sizeof(*ap));
3093 if (av_set_parameters(oc, ap) < 0) {
3094 fprintf(stderr, "%s: Invalid encoding parameters\n",
3099 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3100 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3101 oc->loop_output = loop_output;
3103 for(i=0; i<opt_name_count; i++){
3104 const AVOption *opt;
3105 double d = av_get_double(avformat_opts, opt_names[i], &opt);
3106 if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3107 av_set_double(oc, opt_names[i], d);
3110 /* reset some options */
3111 file_oformat = NULL;
3112 file_iformat = NULL;
3115 /* same option as mencoder */
3116 static void opt_pass(const char *pass_str)
3119 pass = atoi(pass_str);
3120 if (pass != 1 && pass != 2) {
3121 fprintf(stderr, "pass number can be only 1 or 2\n");
3127 #if defined(__MINGW32__) || defined(CONFIG_OS2)
3128 static int64_t getutime(void)
3130 return av_gettime();
3133 static int64_t getutime(void)
3135 struct rusage rusage;
3137 getrusage(RUSAGE_SELF, &rusage);
3138 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3142 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3143 extern int ffm_nopts;
3146 static void show_formats(void)
3148 AVInputFormat *ifmt;
3149 AVOutputFormat *ofmt;
3152 const char **pp, *last_name;
3154 printf("File formats:\n");
3159 const char *name=NULL;
3160 const char *long_name=NULL;
3162 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3163 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3164 strcmp(ofmt->name, last_name)>0){
3166 long_name= ofmt->long_name;
3170 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3171 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3172 strcmp(ifmt->name, last_name)>0){
3174 long_name= ifmt->long_name;
3177 if(name && strcmp(ifmt->name, name)==0)
3189 long_name ? long_name:" ");
3193 printf("Codecs:\n");
3199 const char *type_str;
3202 for(p = first_avcodec; p != NULL; p = p->next) {
3203 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3204 strcmp(p->name, last_name)>0){
3206 decode= encode= cap=0;
3208 if(p2 && strcmp(p->name, p2->name)==0){
3209 if(p->decode) decode=1;
3210 if(p->encode) encode=1;
3211 cap |= p->capabilities;
3216 last_name= p2->name;
3219 case CODEC_TYPE_VIDEO:
3222 case CODEC_TYPE_AUDIO:
3225 case CODEC_TYPE_SUBTITLE:
3234 decode ? "D": (/*p2->decoder ? "d":*/" "),
3237 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3238 cap & CODEC_CAP_DR1 ? "D":" ",
3239 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3241 /* if(p2->decoder && decode==0)
3242 printf(" use %s for decoding", p2->decoder->name);*/
3247 printf("Supported file protocols:\n");
3248 for(up = first_protocol; up != NULL; up = up->next)
3249 printf(" %s:", up->name);
3252 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3253 printf("Motion estimation methods:\n");
3257 if ((pp - motion_str + 1) == ME_ZERO)
3258 printf("(fastest)");
3259 else if ((pp - motion_str + 1) == ME_FULL)
3260 printf("(slowest)");
3261 else if ((pp - motion_str + 1) == ME_EPZS)
3262 printf("(default)");
3267 "Note, the names of encoders and decoders dont always match, so there are\n"
3268 "several cases where the above table shows encoder only or decoder only entries\n"
3269 "even though both encoding and decoding are supported for example, the h263\n"
3270 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3275 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3278 const char *p = str;
3285 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3292 static void opt_inter_matrix(const char *arg)
3294 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3295 parse_matrix_coeffs(inter_matrix, arg);
3298 static void opt_intra_matrix(const char *arg)
3300 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3301 parse_matrix_coeffs(intra_matrix, arg);
3304 static void opt_target(const char *arg)
3307 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3309 if(!strncmp(arg, "pal-", 4)) {
3312 } else if(!strncmp(arg, "ntsc-", 5)) {
3315 } else if(!strncmp(arg, "film-", 5)) {
3320 /* Calculate FR via float to avoid int overflow */
3321 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3324 } else if((fr == 29970) || (fr == 23976)) {
3327 /* Try to determine PAL/NTSC by peeking in the input files */
3328 if(nb_input_files) {
3330 for(j = 0; j < nb_input_files; j++) {
3331 for(i = 0; i < input_files[j]->nb_streams; i++) {
3332 AVCodecContext *c = input_files[j]->streams[i]->codec;
3333 if(c->codec_type != CODEC_TYPE_VIDEO)
3335 fr = c->time_base.den * 1000 / c->time_base.num;
3339 } else if((fr == 29970) || (fr == 23976)) {
3349 if(verbose && norm >= 0)
3350 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3354 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3355 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3356 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3360 if(!strcmp(arg, "vcd")) {
3362 opt_video_codec("mpeg1video");
3363 opt_audio_codec("mp2");
3366 opt_frame_size(norm ? "352x240" : "352x288");
3367 opt_frame_rate(frame_rates[norm]);
3368 opt_default("gop", norm ? "18" : "15");
3370 opt_default("b", "1150000");
3371 opt_default("maxrate", "1150000");
3372 opt_default("minrate", "1150000");
3373 opt_default("bufsize", "327680"); // 40*1024*8;
3375 opt_default("ab", "224000");
3376 audio_sample_rate = 44100;
3379 opt_default("packetsize", "2324");
3380 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3382 /* We have to offset the PTS, so that it is consistent with the SCR.
3383 SCR starts at 36000, but the first two packs contain only padding
3384 and the first pack from the other stream, respectively, may also have
3385 been written before.
3386 So the real data starts at SCR 36000+3*1200. */
3387 mux_preload= (36000+3*1200) / 90000.0; //0.44
3388 } else if(!strcmp(arg, "svcd")) {
3390 opt_video_codec("mpeg2video");
3391 opt_audio_codec("mp2");
3394 opt_frame_size(norm ? "480x480" : "480x576");
3395 opt_frame_rate(frame_rates[norm]);
3396 opt_default("gop", norm ? "18" : "15");
3398 opt_default("b", "2040000");
3399 opt_default("maxrate", "2516000");
3400 opt_default("minrate", "0"); //1145000;
3401 opt_default("bufsize", "1835008"); //224*1024*8;
3402 opt_default("flags", "+SCAN_OFFSET");
3405 opt_default("ab", "224000");
3406 audio_sample_rate = 44100;
3408 opt_default("packetsize", "2324");
3410 } else if(!strcmp(arg, "dvd")) {
3412 opt_video_codec("mpeg2video");
3413 opt_audio_codec("ac3");
3416 opt_frame_size(norm ? "720x480" : "720x576");
3417 opt_frame_rate(frame_rates[norm]);
3418 opt_default("gop", norm ? "18" : "15");
3420 opt_default("b", "6000000");
3421 opt_default("maxrate", "9000000");
3422 opt_default("minrate", "0"); //1500000;
3423 opt_default("bufsize", "1835008"); //224*1024*8;
3425 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3426 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3428 opt_default("ab", "448000");
3429 audio_sample_rate = 48000;
3431 } else if(!strncmp(arg, "dv", 2)) {
3435 opt_frame_size(norm ? "720x480" : "720x576");
3436 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3437 (norm ? "yuv411p" : "yuv420p"));
3438 opt_frame_rate(frame_rates[norm]);
3440 audio_sample_rate = 48000;
3444 fprintf(stderr, "Unknown target: %s\n", arg);
3449 static void opt_video_bsf(const char *arg)
3451 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3452 AVBitStreamFilterContext **bsfp;
3455 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3459 bsfp= &video_bitstream_filters;
3461 bsfp= &(*bsfp)->next;
3466 //FIXME avoid audio - video code duplication
3467 static void opt_audio_bsf(const char *arg)
3469 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3470 AVBitStreamFilterContext **bsfp;
3473 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3477 bsfp= &audio_bitstream_filters;
3479 bsfp= &(*bsfp)->next;
3484 static void show_version(void)
3486 /* TODO: add function interface to avutil and avformat */
3487 fprintf(stderr, "ffmpeg " FFMPEG_VERSION "\n"
3491 LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3495 static int opt_default(const char *opt, const char *arg){
3497 const AVOption *o= NULL;
3498 int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
3500 for(type=0; type<CODEC_TYPE_NB; type++){
3501 const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
3503 o = av_set_string(avctx_opts[type], opt, arg);
3506 o = av_set_string(avformat_opts, opt, arg);
3509 o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
3510 else if(opt[0] == 'v')
3511 o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
3512 else if(opt[0] == 's')
3513 o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
3518 // 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));
3520 //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3521 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3522 opt_names[opt_name_count++]= o->name;
3524 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3525 /* disable generate of real time pts in ffm (need to be supressed anyway) */
3526 if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)
3530 if(avctx_opts[0]->debug)
3531 av_log_level = AV_LOG_DEBUG;
3535 const OptionDef options[] = {
3537 { "L", 0, {(void*)show_license}, "show license" },
3538 { "h", 0, {(void*)show_help}, "show help" },
3539 { "version", 0, {(void*)show_version}, "show version" },
3540 { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3541 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3542 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3543 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3544 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3545 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3546 { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3547 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3548 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3549 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3550 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3551 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3552 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3553 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3554 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3555 { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3556 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3557 "add timings for benchmarking" },
3558 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3559 "dump each input packet" },
3560 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3561 "when dumping packets, also dump the payload" },
3562 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3563 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3564 { "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)", "" },
3565 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3566 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3567 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3568 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3569 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3570 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3571 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3572 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3573 { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3576 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3577 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3578 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3579 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3580 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3581 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3582 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3583 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3584 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3585 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3586 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3587 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3588 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3589 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3590 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3591 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3592 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3593 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3594 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3595 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
3596 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3597 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3598 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3599 { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3601 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
3602 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3603 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3604 "use same video quality as source (implies VBR)" },
3605 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3606 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3607 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3608 "deinterlace pictures" },
3609 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3610 { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
3611 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3612 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3613 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3614 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3615 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3616 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3617 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3618 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3621 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3622 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3623 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3624 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3625 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3626 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3627 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3628 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3629 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3630 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3632 /* subtitle options */
3633 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3634 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3635 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3638 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3639 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3640 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3643 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3644 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3646 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
3647 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
3649 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3653 static void show_banner(void)
3655 fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2007 Fabrice Bellard, et al.\n");
3656 fprintf(stderr, " configuration: " FFMPEG_CONFIGURATION "\n");
3657 fprintf(stderr, " libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
3658 fprintf(stderr, " libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
3659 fprintf(stderr, " libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
3660 fprintf(stderr, " built on " __DATE__ " " __TIME__);
3662 fprintf(stderr, ", gcc: " __VERSION__ "\n");
3664 fprintf(stderr, ", using a non-gcc compiler\n");
3668 static void show_license(void)
3673 "FFmpeg is free software; you can redistribute it and/or modify\n"
3674 "it under the terms of the GNU General Public License as published by\n"
3675 "the Free Software Foundation; either version 2 of the License, or\n"
3676 "(at your option) any later version.\n"
3678 "FFmpeg is distributed in the hope that it will be useful,\n"
3679 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3680 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
3681 "GNU General Public License for more details.\n"
3683 "You should have received a copy of the GNU General Public License\n"
3684 "along with FFmpeg; if not, write to the Free Software\n"
3685 "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
3689 "FFmpeg is free software; you can redistribute it and/or\n"
3690 "modify it under the terms of the GNU Lesser General Public\n"
3691 "License as published by the Free Software Foundation; either\n"
3692 "version 2.1 of the License, or (at your option) any later version.\n"
3694 "FFmpeg is distributed in the hope that it will be useful,\n"
3695 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3696 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
3697 "Lesser General Public License for more details.\n"
3699 "You should have received a copy of the GNU Lesser General Public\n"
3700 "License along with FFmpeg; if not, write to the Free Software\n"
3701 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
3707 static void show_help(void)
3710 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3711 "Hyper fast Audio and Video encoder\n");
3713 show_help_options(options, "Main options:\n",
3714 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3715 show_help_options(options, "\nVideo options:\n",
3716 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3718 show_help_options(options, "\nAdvanced Video options:\n",
3719 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3720 OPT_VIDEO | OPT_EXPERT);
3721 show_help_options(options, "\nAudio options:\n",
3722 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3724 show_help_options(options, "\nAdvanced Audio options:\n",
3725 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3726 OPT_AUDIO | OPT_EXPERT);
3727 show_help_options(options, "\nSubtitle options:\n",
3728 OPT_SUBTITLE | OPT_GRAB,
3730 show_help_options(options, "\nAudio/Video grab options:\n",
3733 show_help_options(options, "\nAdvanced options:\n",
3734 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3736 av_opt_show(avctx_opts[0], NULL);
3737 av_opt_show(avformat_opts, NULL);
3742 void parse_arg_file(const char *filename)
3744 opt_output_file(filename);
3747 int main(int argc, char **argv)
3754 for(i=0; i<CODEC_TYPE_NB; i++){
3755 avctx_opts[i]= avcodec_alloc_context2(i);
3757 avformat_opts = av_alloc_format_context();
3765 parse_options(argc, argv, options);
3767 /* file converter / grab */
3768 if (nb_output_files <= 0) {
3769 fprintf(stderr, "Must supply at least one output file\n");
3773 if (nb_input_files == 0) {
3774 fprintf(stderr, "Must supply at least one input file\n");
3779 av_encode(output_files, nb_output_files, input_files, nb_input_files,
3780 stream_maps, nb_stream_maps);
3781 ti = getutime() - ti;
3783 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3787 for(i=0;i<nb_output_files;i++) {
3788 /* maybe av_close_output_file ??? */
3789 AVFormatContext *s = output_files[i];
3791 if (!(s->oformat->flags & AVFMT_NOFILE))
3793 for(j=0;j<s->nb_streams;j++) {
3794 av_free(s->streams[j]->codec);
3795 av_free(s->streams[j]);
3799 for(i=0;i<nb_input_files;i++)
3800 av_close_input_file(input_files[i]);
3804 av_free(intra_matrix);
3805 av_free(inter_matrix);
3808 #ifdef CONFIG_POWERPC_PERF
3809 extern void powerpc_display_perf_report(void);
3810 powerpc_display_perf_report();
3811 #endif /* CONFIG_POWERPC_PERF */
3813 if (received_sigterm) {
3815 "Received signal %d: terminating.\n",
3816 (int) received_sigterm);
3820 exit(0); /* not all OS-es handle main() return value */