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 ) ) {
1614 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1617 ost->img_resample_ctx = sws_getContext(
1618 icodec->width - (frame_leftBand + frame_rightBand),
1619 icodec->height - (frame_topBand + frame_bottomBand),
1621 codec->width - (frame_padleft + frame_padright),
1622 codec->height - (frame_padtop + frame_padbottom),
1624 sws_flags, NULL, NULL, NULL);
1625 if (ost->img_resample_ctx == NULL) {
1626 fprintf(stderr, "Cannot get resampling context\n");
1629 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1631 ost->encoding_needed = 1;
1632 ist->decoding_needed = 1;
1634 case CODEC_TYPE_SUBTITLE:
1635 ost->encoding_needed = 1;
1636 ist->decoding_needed = 1;
1643 if (ost->encoding_needed &&
1644 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1645 char logfilename[1024];
1650 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1652 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1653 if (codec->flags & CODEC_FLAG_PASS1) {
1654 f = fopen(logfilename, "w");
1656 perror(logfilename);
1661 /* read the log file */
1662 f = fopen(logfilename, "r");
1664 perror(logfilename);
1667 fseek(f, 0, SEEK_END);
1669 fseek(f, 0, SEEK_SET);
1670 logbuffer = av_malloc(size + 1);
1672 fprintf(stderr, "Could not allocate log buffer\n");
1675 size = fread(logbuffer, 1, size, f);
1677 logbuffer[size] = '\0';
1678 codec->stats_in = logbuffer;
1682 if(codec->codec_type == CODEC_TYPE_VIDEO){
1683 int size= codec->width * codec->height;
1684 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1689 bit_buffer = av_malloc(bit_buffer_size);
1693 /* dump the file output parameters - cannot be done before in case
1695 for(i=0;i<nb_output_files;i++) {
1696 dump_format(output_files[i], i, output_files[i]->filename, 1);
1699 /* dump the stream mapping */
1701 fprintf(stderr, "Stream mapping:\n");
1702 for(i=0;i<nb_ostreams;i++) {
1704 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1705 ist_table[ost->source_index]->file_index,
1706 ist_table[ost->source_index]->index,
1709 if (ost->sync_ist != ist_table[ost->source_index])
1710 fprintf(stderr, " [sync #%d.%d]",
1711 ost->sync_ist->file_index,
1712 ost->sync_ist->index);
1713 fprintf(stderr, "\n");
1717 /* open each encoder */
1718 for(i=0;i<nb_ostreams;i++) {
1720 if (ost->encoding_needed) {
1722 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1724 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1725 ost->file_index, ost->index);
1728 if (avcodec_open(ost->st->codec, codec) < 0) {
1729 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1730 ost->file_index, ost->index);
1733 extra_size += ost->st->codec->extradata_size;
1737 /* open each decoder */
1738 for(i=0;i<nb_istreams;i++) {
1740 if (ist->decoding_needed) {
1742 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1744 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1745 ist->st->codec->codec_id, ist->file_index, ist->index);
1748 if (avcodec_open(ist->st->codec, codec) < 0) {
1749 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1750 ist->file_index, ist->index);
1753 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1754 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1759 for(i=0;i<nb_istreams;i++) {
1761 is = input_files[ist->file_index];
1763 ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1764 if(ist->st->start_time == AV_NOPTS_VALUE)
1766 if(input_files_ts_offset[ist->file_index])
1767 ist->next_pts= AV_NOPTS_VALUE;
1771 /* set meta data information from input file if required */
1772 for (i=0;i<nb_meta_data_maps;i++) {
1773 AVFormatContext *out_file;
1774 AVFormatContext *in_file;
1776 int out_file_index = meta_data_maps[i].out_file;
1777 int in_file_index = meta_data_maps[i].in_file;
1778 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1779 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1780 ret = AVERROR(EINVAL);
1783 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1784 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1785 ret = AVERROR(EINVAL);
1789 out_file = output_files[out_file_index];
1790 in_file = input_files[in_file_index];
1792 strcpy(out_file->title, in_file->title);
1793 strcpy(out_file->author, in_file->author);
1794 strcpy(out_file->copyright, in_file->copyright);
1795 strcpy(out_file->comment, in_file->comment);
1796 strcpy(out_file->album, in_file->album);
1797 out_file->year = in_file->year;
1798 out_file->track = in_file->track;
1799 strcpy(out_file->genre, in_file->genre);
1802 /* open files and write file headers */
1803 for(i=0;i<nb_output_files;i++) {
1804 os = output_files[i];
1805 if (av_write_header(os) < 0) {
1806 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1807 ret = AVERROR(EINVAL);
1812 if ( !using_stdin && verbose >= 0) {
1813 fprintf(stderr, "Press [q] to stop encoding\n");
1814 url_set_interrupt_cb(decode_interrupt_cb);
1819 timer_start = av_gettime();
1821 for(; received_sigterm == 0;) {
1822 int file_index, ist_index;
1830 /* if 'q' pressed, exits */
1834 /* read_key() returns 0 on EOF */
1840 /* select the stream that we must read now by looking at the
1841 smallest output pts */
1843 for(i=0;i<nb_ostreams;i++) {
1846 os = output_files[ost->file_index];
1847 ist = ist_table[ost->source_index];
1848 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1849 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1851 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1852 ipts = (double)ist->pts;
1853 if (!file_table[ist->file_index].eof_reached){
1854 if(ipts < ipts_min) {
1856 if(input_sync ) file_index = ist->file_index;
1858 if(opts < opts_min) {
1860 if(!input_sync) file_index = ist->file_index;
1863 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1868 /* if none, if is finished */
1869 if (file_index < 0) {
1873 /* finish if recording time exhausted */
1874 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1877 /* finish if limit size exhausted */
1878 if (limit_filesize != 0 && limit_filesize < url_ftell(&output_files[0]->pb))
1881 /* read a frame from it and output it in the fifo */
1882 is = input_files[file_index];
1883 if (av_read_frame(is, &pkt) < 0) {
1884 file_table[file_index].eof_reached = 1;
1885 if (opt_shortest) break; else continue; //
1889 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
1891 /* the following test is needed in case new streams appear
1892 dynamically in stream : we ignore them */
1893 if (pkt.stream_index >= file_table[file_index].nb_streams)
1894 goto discard_packet;
1895 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1896 ist = ist_table[ist_index];
1898 goto discard_packet;
1900 // 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);
1901 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1902 int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1903 if(FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1904 input_files_ts_offset[ist->file_index]-= delta;
1906 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1907 for(i=0; i<file_table[file_index].nb_streams; i++){
1908 int index= file_table[file_index].ist_index + i;
1909 ist_table[index]->next_pts += delta;
1910 ist_table[index]->is_start=1;
1915 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1916 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1919 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1920 ist->file_index, ist->index);
1922 av_free_packet(&pkt);
1927 av_free_packet(&pkt);
1929 /* dump report by using the output first video and audio streams */
1930 print_report(output_files, ost_table, nb_ostreams, 0);
1933 /* at the end of stream, we must flush the decoder buffers */
1934 for(i=0;i<nb_istreams;i++) {
1936 if (ist->decoding_needed) {
1937 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1943 /* write the trailer if needed and close file */
1944 for(i=0;i<nb_output_files;i++) {
1945 os = output_files[i];
1946 av_write_trailer(os);
1949 /* dump report by using the first video and audio streams */
1950 print_report(output_files, ost_table, nb_ostreams, 1);
1952 /* close each encoder */
1953 for(i=0;i<nb_ostreams;i++) {
1955 if (ost->encoding_needed) {
1956 av_freep(&ost->st->codec->stats_in);
1957 avcodec_close(ost->st->codec);
1961 /* close each decoder */
1962 for(i=0;i<nb_istreams;i++) {
1964 if (ist->decoding_needed) {
1965 avcodec_close(ist->st->codec);
1973 av_freep(&bit_buffer);
1974 av_free(file_table);
1977 for(i=0;i<nb_istreams;i++) {
1984 for(i=0;i<nb_ostreams;i++) {
1988 fclose(ost->logfile);
1989 ost->logfile = NULL;
1991 av_fifo_free(&ost->fifo); /* works even if fifo is not
1992 initialized but set to zero */
1993 av_free(ost->pict_tmp.data[0]);
1994 if (ost->video_resample)
1995 sws_freeContext(ost->img_resample_ctx);
1996 if (ost->audio_resample)
1997 audio_resample_close(ost->resample);
2005 ret = AVERROR(ENOMEM);
2010 int file_read(const char *filename)
2013 unsigned char buffer[1024];
2016 if (url_open(&h, filename, O_RDONLY) < 0) {
2017 printf("could not open '%s'\n", filename);
2021 len = url_read(h, buffer, sizeof(buffer));
2024 for(i=0;i<len;i++) putchar(buffer[i]);
2031 static void opt_format(const char *arg)
2033 /* compatibility stuff for pgmyuv */
2034 if (!strcmp(arg, "pgmyuv")) {
2035 pgmyuv_compatibility_hack=1;
2036 // opt_image_format(arg);
2038 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2041 file_iformat = av_find_input_format(arg);
2042 file_oformat = guess_format(arg, NULL, NULL);
2043 if (!file_iformat && !file_oformat) {
2044 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2049 static void opt_video_rc_eq(char *arg)
2054 static void opt_video_rc_override_string(char *arg)
2056 video_rc_override_string = arg;
2059 static void opt_me_threshold(const char *arg)
2061 me_threshold = atoi(arg);
2064 static void opt_verbose(const char *arg)
2066 verbose = atoi(arg);
2067 av_log_level = atoi(arg);
2070 static void opt_frame_rate(const char *arg)
2072 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2073 fprintf(stderr, "Incorrect frame rate\n");
2078 static void opt_frame_crop_top(const char *arg)
2080 frame_topBand = atoi(arg);
2081 if (frame_topBand < 0) {
2082 fprintf(stderr, "Incorrect top crop size\n");
2085 if ((frame_topBand % 2) != 0) {
2086 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2089 if ((frame_topBand) >= frame_height){
2090 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2093 frame_height -= frame_topBand;
2096 static void opt_frame_crop_bottom(const char *arg)
2098 frame_bottomBand = atoi(arg);
2099 if (frame_bottomBand < 0) {
2100 fprintf(stderr, "Incorrect bottom crop size\n");
2103 if ((frame_bottomBand % 2) != 0) {
2104 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2107 if ((frame_bottomBand) >= frame_height){
2108 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2111 frame_height -= frame_bottomBand;
2114 static void opt_frame_crop_left(const char *arg)
2116 frame_leftBand = atoi(arg);
2117 if (frame_leftBand < 0) {
2118 fprintf(stderr, "Incorrect left crop size\n");
2121 if ((frame_leftBand % 2) != 0) {
2122 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2125 if ((frame_leftBand) >= frame_width){
2126 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2129 frame_width -= frame_leftBand;
2132 static void opt_frame_crop_right(const char *arg)
2134 frame_rightBand = atoi(arg);
2135 if (frame_rightBand < 0) {
2136 fprintf(stderr, "Incorrect right crop size\n");
2139 if ((frame_rightBand % 2) != 0) {
2140 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2143 if ((frame_rightBand) >= frame_width){
2144 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2147 frame_width -= frame_rightBand;
2150 static void opt_frame_size(const char *arg)
2152 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2153 fprintf(stderr, "Incorrect frame size\n");
2156 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2157 fprintf(stderr, "Frame size must be a multiple of 2\n");
2163 #define SCALEBITS 10
2164 #define ONE_HALF (1 << (SCALEBITS - 1))
2165 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2167 #define RGB_TO_Y(r, g, b) \
2168 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2169 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2171 #define RGB_TO_U(r1, g1, b1, shift)\
2172 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2173 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2175 #define RGB_TO_V(r1, g1, b1, shift)\
2176 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2177 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2179 static void opt_pad_color(const char *arg) {
2180 /* Input is expected to be six hex digits similar to
2181 how colors are expressed in html tags (but without the #) */
2182 int rgb = strtol(arg, NULL, 16);
2186 g = ((rgb >> 8) & 255);
2189 padcolor[0] = RGB_TO_Y(r,g,b);
2190 padcolor[1] = RGB_TO_U(r,g,b,0);
2191 padcolor[2] = RGB_TO_V(r,g,b,0);
2194 static void opt_frame_pad_top(const char *arg)
2196 frame_padtop = atoi(arg);
2197 if (frame_padtop < 0) {
2198 fprintf(stderr, "Incorrect top pad size\n");
2201 if ((frame_padtop % 2) != 0) {
2202 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2207 static void opt_frame_pad_bottom(const char *arg)
2209 frame_padbottom = atoi(arg);
2210 if (frame_padbottom < 0) {
2211 fprintf(stderr, "Incorrect bottom pad size\n");
2214 if ((frame_padbottom % 2) != 0) {
2215 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2221 static void opt_frame_pad_left(const char *arg)
2223 frame_padleft = atoi(arg);
2224 if (frame_padleft < 0) {
2225 fprintf(stderr, "Incorrect left pad size\n");
2228 if ((frame_padleft % 2) != 0) {
2229 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2235 static void opt_frame_pad_right(const char *arg)
2237 frame_padright = atoi(arg);
2238 if (frame_padright < 0) {
2239 fprintf(stderr, "Incorrect right pad size\n");
2242 if ((frame_padright % 2) != 0) {
2243 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2249 static void opt_frame_pix_fmt(const char *arg)
2251 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2254 static void opt_frame_aspect_ratio(const char *arg)
2260 p = strchr(arg, ':');
2262 x = strtol(arg, (char **)&arg, 10);
2264 y = strtol(arg+1, (char **)&arg, 10);
2266 ar = (double)x / (double)y;
2268 ar = strtod(arg, (char **)&arg);
2271 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2274 frame_aspect_ratio = ar;
2277 static void opt_qscale(const char *arg)
2279 video_qscale = atof(arg);
2280 if (video_qscale <= 0 ||
2281 video_qscale > 255) {
2282 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2287 static void opt_qdiff(const char *arg)
2289 video_qdiff = atoi(arg);
2290 if (video_qdiff < 0 ||
2292 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2297 static void opt_strict(const char *arg)
2302 static void opt_top_field_first(const char *arg)
2304 top_field_first= atoi(arg);
2307 static void opt_thread_count(const char *arg)
2309 thread_count= atoi(arg);
2310 #if !defined(HAVE_THREADS)
2312 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2316 static void opt_audio_rate(const char *arg)
2318 audio_sample_rate = atoi(arg);
2321 static void opt_audio_channels(const char *arg)
2323 audio_channels = atoi(arg);
2326 static void opt_video_channel(const char *arg)
2328 video_channel = strtol(arg, NULL, 0);
2331 static void opt_video_standard(const char *arg)
2333 video_standard = av_strdup(arg);
2336 static void opt_codec(int *pstream_copy, int *pcodec_id,
2337 int codec_type, const char *arg)
2341 if (!strcmp(arg, "copy")) {
2346 if (!strcmp(p->name, arg) && p->type == codec_type)
2351 fprintf(stderr, "Unknown codec '%s'\n", arg);
2359 static void opt_audio_codec(const char *arg)
2361 opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2364 static void opt_audio_tag(const char *arg)
2367 audio_codec_tag= strtol(arg, &tail, 0);
2370 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2373 static void opt_video_tag(const char *arg)
2376 video_codec_tag= strtol(arg, &tail, 0);
2379 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2382 static void add_frame_hooker(const char *arg)
2387 char *args = av_strdup(arg);
2391 argv[0] = strtok(args, " ");
2392 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2395 i = frame_hook_add(argc, argv);
2398 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2403 const char *motion_str[] = {
2416 static void opt_motion_estimation(const char *arg)
2422 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2425 if (!strcmp(*p, arg))
2429 me_method = (p - motion_str) + 1;
2432 static void opt_video_codec(const char *arg)
2434 opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2437 static void opt_subtitle_codec(const char *arg)
2439 opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2442 static void opt_map(const char *arg)
2448 m = &stream_maps[nb_stream_maps++];
2450 m->file_index = strtol(arg, (char **)&p, 0);
2454 m->stream_index = strtol(p, (char **)&p, 0);
2457 m->sync_file_index = strtol(p, (char **)&p, 0);
2460 m->sync_stream_index = strtol(p, (char **)&p, 0);
2462 m->sync_file_index = m->file_index;
2463 m->sync_stream_index = m->stream_index;
2467 static void opt_map_meta_data(const char *arg)
2473 m = &meta_data_maps[nb_meta_data_maps++];
2475 m->out_file = strtol(arg, (char **)&p, 0);
2479 m->in_file = strtol(p, (char **)&p, 0);
2482 static void opt_recording_time(const char *arg)
2484 recording_time = parse_date(arg, 1);
2487 static void opt_start_time(const char *arg)
2489 start_time = parse_date(arg, 1);
2492 static void opt_rec_timestamp(const char *arg)
2494 rec_timestamp = parse_date(arg, 0) / 1000000;
2497 static void opt_input_ts_offset(const char *arg)
2499 input_ts_offset = parse_date(arg, 1);
2502 static void opt_input_file(const char *filename)
2504 AVFormatContext *ic;
2505 AVFormatParameters params, *ap = ¶ms;
2506 int err, i, ret, rfps, rfps_base;
2509 if (!strcmp(filename, "-"))
2512 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2513 !strcmp( filename, "/dev/stdin" );
2515 /* get default parameters from command line */
2516 ic = av_alloc_format_context();
2518 memset(ap, 0, sizeof(*ap));
2519 ap->prealloced_context = 1;
2520 ap->sample_rate = audio_sample_rate;
2521 ap->channels = audio_channels;
2522 ap->time_base.den = frame_rate;
2523 ap->time_base.num = frame_rate_base;
2524 ap->width = frame_width + frame_padleft + frame_padright;
2525 ap->height = frame_height + frame_padtop + frame_padbottom;
2526 ap->pix_fmt = frame_pix_fmt;
2527 ap->channel = video_channel;
2528 ap->standard = video_standard;
2529 ap->video_codec_id = video_codec_id;
2530 ap->audio_codec_id = audio_codec_id;
2531 if(pgmyuv_compatibility_hack)
2532 ap->video_codec_id= CODEC_ID_PGMYUV;
2534 for(i=0; i<opt_name_count; i++){
2535 const AVOption *opt;
2536 double d= av_get_double(avformat_opts, opt_names[i], &opt);
2537 if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2538 av_set_double(ic, opt_names[i], d);
2540 /* open the input file with generic libav function */
2541 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2543 print_error(filename, err);
2547 ic->loop_input = loop_input;
2549 /* If not enough info to get the stream parameters, we decode the
2550 first frames to get it. (used in mpeg case for example) */
2551 ret = av_find_stream_info(ic);
2552 if (ret < 0 && verbose >= 0) {
2553 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2557 timestamp = start_time;
2558 /* add the stream start time */
2559 if (ic->start_time != AV_NOPTS_VALUE)
2560 timestamp += ic->start_time;
2562 /* if seeking requested, we execute it */
2563 if (start_time != 0) {
2564 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2566 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2567 filename, (double)timestamp / AV_TIME_BASE);
2569 /* reset seek info */
2573 /* update the current parameters so that they match the one of the input stream */
2574 for(i=0;i<ic->nb_streams;i++) {
2576 AVCodecContext *enc = ic->streams[i]->codec;
2578 avcodec_thread_init(enc, thread_count);
2579 enc->thread_count= thread_count;
2580 switch(enc->codec_type) {
2581 case CODEC_TYPE_AUDIO:
2582 for(j=0; j<opt_name_count; j++){
2583 const AVOption *opt;
2584 double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt);
2585 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2586 av_set_double(enc, opt_names[j], d);
2588 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2589 audio_channels = enc->channels;
2590 audio_sample_rate = enc->sample_rate;
2592 ic->streams[i]->discard= AVDISCARD_ALL;
2594 case CODEC_TYPE_VIDEO:
2595 for(j=0; j<opt_name_count; j++){
2596 const AVOption *opt;
2597 double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt);
2598 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2599 av_set_double(enc, opt_names[j], d);
2601 frame_height = enc->height;
2602 frame_width = enc->width;
2603 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2604 frame_pix_fmt = enc->pix_fmt;
2605 rfps = ic->streams[i]->r_frame_rate.num;
2606 rfps_base = ic->streams[i]->r_frame_rate.den;
2607 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2609 enc->debug |= FF_DEBUG_MV;
2611 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2614 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2615 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2617 (float)rfps / rfps_base, rfps, rfps_base);
2619 /* update the current frame rate to match the stream frame rate */
2621 frame_rate_base = rfps_base;
2623 enc->rate_emu = rate_emu;
2625 ic->streams[i]->discard= AVDISCARD_ALL;
2626 else if(video_discard)
2627 ic->streams[i]->discard= video_discard;
2629 case CODEC_TYPE_DATA:
2631 case CODEC_TYPE_SUBTITLE:
2633 case CODEC_TYPE_UNKNOWN:
2640 input_files[nb_input_files] = ic;
2641 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2642 /* dump the file content */
2644 dump_format(ic, nb_input_files, filename, 0);
2647 file_iformat = NULL;
2648 file_oformat = NULL;
2655 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2657 int has_video, has_audio, i, j;
2658 AVFormatContext *ic;
2662 for(j=0;j<nb_input_files;j++) {
2663 ic = input_files[j];
2664 for(i=0;i<ic->nb_streams;i++) {
2665 AVCodecContext *enc = ic->streams[i]->codec;
2666 switch(enc->codec_type) {
2667 case CODEC_TYPE_AUDIO:
2670 case CODEC_TYPE_VIDEO:
2673 case CODEC_TYPE_DATA:
2674 case CODEC_TYPE_UNKNOWN:
2675 case CODEC_TYPE_SUBTITLE:
2682 *has_video_ptr = has_video;
2683 *has_audio_ptr = has_audio;
2686 static void new_video_stream(AVFormatContext *oc)
2689 AVCodecContext *video_enc;
2692 st = av_new_stream(oc, oc->nb_streams);
2694 fprintf(stderr, "Could not alloc stream\n");
2697 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2698 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2699 video_bitstream_filters= NULL;
2702 avcodec_thread_init(st->codec, thread_count);
2704 video_enc = st->codec;
2707 video_enc->codec_tag= video_codec_tag;
2709 if( (video_global_header&1)
2710 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2711 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2712 avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2714 if(video_global_header&2){
2715 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2716 avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2719 if (video_stream_copy) {
2720 st->stream_copy = 1;
2721 video_enc->codec_type = CODEC_TYPE_VIDEO;
2727 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2728 if (video_codec_id != CODEC_ID_NONE)
2729 codec_id = video_codec_id;
2731 video_enc->codec_id = codec_id;
2732 codec = avcodec_find_encoder(codec_id);
2734 for(i=0; i<opt_name_count; i++){
2735 const AVOption *opt;
2736 double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt);
2737 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2738 av_set_double(video_enc, opt_names[i], d);
2741 video_enc->time_base.den = frame_rate;
2742 video_enc->time_base.num = frame_rate_base;
2743 if(codec && codec->supported_framerates){
2744 const AVRational *p= codec->supported_framerates;
2745 AVRational req= (AVRational){frame_rate, frame_rate_base};
2746 const AVRational *best=NULL;
2747 AVRational best_error= (AVRational){INT_MAX, 1};
2748 for(; p->den!=0; p++){
2749 AVRational error= av_sub_q(req, *p);
2750 if(error.num <0) error.num *= -1;
2751 if(av_cmp_q(error, best_error) < 0){
2756 video_enc->time_base.den= best->num;
2757 video_enc->time_base.num= best->den;
2760 video_enc->width = frame_width + frame_padright + frame_padleft;
2761 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2762 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2763 video_enc->pix_fmt = frame_pix_fmt;
2765 if(codec && codec->pix_fmts){
2766 const enum PixelFormat *p= codec->pix_fmts;
2768 if(*p == video_enc->pix_fmt)
2772 video_enc->pix_fmt = codec->pix_fmts[0];
2776 video_enc->gop_size = 0;
2777 if (video_qscale || same_quality) {
2778 video_enc->flags |= CODEC_FLAG_QSCALE;
2779 video_enc->global_quality=
2780 st->quality = FF_QP2LAMBDA * video_qscale;
2784 video_enc->intra_matrix = intra_matrix;
2786 video_enc->inter_matrix = inter_matrix;
2788 video_enc->max_qdiff = video_qdiff;
2789 video_enc->rc_eq = video_rc_eq;
2790 video_enc->thread_count = thread_count;
2791 p= video_rc_override_string;
2794 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2796 fprintf(stderr, "error parsing rc_override\n");
2799 video_enc->rc_override=
2800 av_realloc(video_enc->rc_override,
2801 sizeof(RcOverride)*(i+1));
2802 video_enc->rc_override[i].start_frame= start;
2803 video_enc->rc_override[i].end_frame = end;
2805 video_enc->rc_override[i].qscale= q;
2806 video_enc->rc_override[i].quality_factor= 1.0;
2809 video_enc->rc_override[i].qscale= 0;
2810 video_enc->rc_override[i].quality_factor= -q/100.0;
2815 video_enc->rc_override_count=i;
2816 if (!video_enc->rc_initial_buffer_occupancy)
2817 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2818 video_enc->me_threshold= me_threshold;
2819 video_enc->intra_dc_precision= intra_dc_precision - 8;
2820 video_enc->strict_std_compliance = strict;
2823 video_enc->flags|= CODEC_FLAG_PSNR;
2825 video_enc->me_method = me_method;
2830 video_enc->flags |= CODEC_FLAG_PASS1;
2832 video_enc->flags |= CODEC_FLAG_PASS2;
2837 /* reset some key parameters */
2839 video_codec_id = CODEC_ID_NONE;
2840 video_stream_copy = 0;
2843 static void new_audio_stream(AVFormatContext *oc)
2846 AVCodecContext *audio_enc;
2849 st = av_new_stream(oc, oc->nb_streams);
2851 fprintf(stderr, "Could not alloc stream\n");
2854 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
2856 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2857 audio_bitstream_filters= NULL;
2860 avcodec_thread_init(st->codec, thread_count);
2862 audio_enc = st->codec;
2863 audio_enc->codec_type = CODEC_TYPE_AUDIO;
2864 audio_enc->strict_std_compliance = strict;
2867 audio_enc->codec_tag= audio_codec_tag;
2869 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2870 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2871 avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2873 if (audio_stream_copy) {
2874 st->stream_copy = 1;
2875 audio_enc->channels = audio_channels;
2877 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2879 for(i=0; i<opt_name_count; i++){
2880 const AVOption *opt;
2881 double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt);
2882 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2883 av_set_double(audio_enc, opt_names[i], d);
2886 if (audio_codec_id != CODEC_ID_NONE)
2887 codec_id = audio_codec_id;
2888 audio_enc->codec_id = codec_id;
2890 if (audio_qscale > QSCALE_NONE) {
2891 audio_enc->flags |= CODEC_FLAG_QSCALE;
2892 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
2894 audio_enc->thread_count = thread_count;
2895 audio_enc->channels = audio_channels;
2897 audio_enc->sample_rate = audio_sample_rate;
2898 audio_enc->time_base= (AVRational){1, audio_sample_rate};
2899 if (audio_language) {
2900 pstrcpy(st->language, sizeof(st->language), audio_language);
2901 av_free(audio_language);
2902 audio_language = NULL;
2905 /* reset some key parameters */
2907 audio_codec_id = CODEC_ID_NONE;
2908 audio_stream_copy = 0;
2911 static void opt_new_subtitle_stream(void)
2913 AVFormatContext *oc;
2915 AVCodecContext *subtitle_enc;
2918 if (nb_output_files <= 0) {
2919 fprintf(stderr, "At least one output file must be specified\n");
2922 oc = output_files[nb_output_files - 1];
2924 st = av_new_stream(oc, oc->nb_streams);
2926 fprintf(stderr, "Could not alloc stream\n");
2929 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
2931 subtitle_enc = st->codec;
2932 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
2933 if (subtitle_stream_copy) {
2934 st->stream_copy = 1;
2936 for(i=0; i<opt_name_count; i++){
2937 const AVOption *opt;
2938 double d= av_get_double(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt);
2939 if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2940 av_set_double(subtitle_enc, opt_names[i], d);
2942 subtitle_enc->codec_id = subtitle_codec_id;
2945 if (subtitle_language) {
2946 pstrcpy(st->language, sizeof(st->language), subtitle_language);
2947 av_free(subtitle_language);
2948 subtitle_language = NULL;
2951 subtitle_codec_id = CODEC_ID_NONE;
2952 subtitle_stream_copy = 0;
2955 static void opt_new_audio_stream(void)
2957 AVFormatContext *oc;
2958 if (nb_output_files <= 0) {
2959 fprintf(stderr, "At least one output file must be specified\n");
2962 oc = output_files[nb_output_files - 1];
2963 new_audio_stream(oc);
2966 static void opt_new_video_stream(void)
2968 AVFormatContext *oc;
2969 if (nb_output_files <= 0) {
2970 fprintf(stderr, "At least one output file must be specified\n");
2973 oc = output_files[nb_output_files - 1];
2974 new_video_stream(oc);
2977 static void opt_output_file(const char *filename)
2979 AVFormatContext *oc;
2980 int use_video, use_audio, input_has_video, input_has_audio, i;
2981 AVFormatParameters params, *ap = ¶ms;
2983 if (!strcmp(filename, "-"))
2986 oc = av_alloc_format_context();
2988 if (!file_oformat) {
2989 file_oformat = guess_format(NULL, filename, NULL);
2990 if (!file_oformat) {
2991 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
2997 oc->oformat = file_oformat;
2998 pstrcpy(oc->filename, sizeof(oc->filename), filename);
3000 if (!strcmp(file_oformat->name, "ffm") &&
3001 strstart(filename, "http:", NULL)) {
3002 /* special case for files sent to ffserver: we get the stream
3003 parameters from ffserver */
3004 if (read_ffserver_streams(oc, filename) < 0) {
3005 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3009 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3010 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3012 /* disable if no corresponding type found and at least one
3014 if (nb_input_files > 0) {
3015 check_audio_video_inputs(&input_has_video, &input_has_audio);
3016 if (!input_has_video)
3018 if (!input_has_audio)
3022 /* manual disable */
3023 if (audio_disable) {
3026 if (video_disable) {
3031 new_video_stream(oc);
3035 new_audio_stream(oc);
3038 oc->timestamp = rec_timestamp;
3041 pstrcpy(oc->title, sizeof(oc->title), str_title);
3043 pstrcpy(oc->author, sizeof(oc->author), str_author);
3045 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3047 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3049 pstrcpy(oc->album, sizeof(oc->album), str_album);
3052 output_files[nb_output_files++] = oc;
3054 /* check filename in case of an image number is expected */
3055 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3056 if (!av_filename_number_test(oc->filename)) {
3057 print_error(oc->filename, AVERROR_NUMEXPECTED);
3062 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3063 /* test if it already exists to avoid loosing precious files */
3064 if (!file_overwrite &&
3065 (strchr(filename, ':') == NULL ||
3066 strstart(filename, "file:", NULL))) {
3067 if (url_exist(filename)) {
3070 if ( !using_stdin ) {
3071 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3074 if (toupper(c) != 'Y') {
3075 fprintf(stderr, "Not overwriting - exiting\n");
3080 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3087 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3088 fprintf(stderr, "Could not open '%s'\n", filename);
3093 memset(ap, 0, sizeof(*ap));
3094 if (av_set_parameters(oc, ap) < 0) {
3095 fprintf(stderr, "%s: Invalid encoding parameters\n",
3100 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3101 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3102 oc->loop_output = loop_output;
3104 for(i=0; i<opt_name_count; i++){
3105 const AVOption *opt;
3106 double d = av_get_double(avformat_opts, opt_names[i], &opt);
3107 if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3108 av_set_double(oc, opt_names[i], d);
3111 /* reset some options */
3112 file_oformat = NULL;
3113 file_iformat = NULL;
3116 /* same option as mencoder */
3117 static void opt_pass(const char *pass_str)
3120 pass = atoi(pass_str);
3121 if (pass != 1 && pass != 2) {
3122 fprintf(stderr, "pass number can be only 1 or 2\n");
3128 #if defined(__MINGW32__) || defined(CONFIG_OS2)
3129 static int64_t getutime(void)
3131 return av_gettime();
3134 static int64_t getutime(void)
3136 struct rusage rusage;
3138 getrusage(RUSAGE_SELF, &rusage);
3139 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3143 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3144 extern int ffm_nopts;
3147 static void show_formats(void)
3149 AVInputFormat *ifmt;
3150 AVOutputFormat *ofmt;
3153 const char **pp, *last_name;
3155 printf("File formats:\n");
3160 const char *name=NULL;
3161 const char *long_name=NULL;
3163 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3164 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3165 strcmp(ofmt->name, last_name)>0){
3167 long_name= ofmt->long_name;
3171 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3172 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3173 strcmp(ifmt->name, last_name)>0){
3175 long_name= ifmt->long_name;
3178 if(name && strcmp(ifmt->name, name)==0)
3190 long_name ? long_name:" ");
3194 printf("Codecs:\n");
3200 const char *type_str;
3203 for(p = first_avcodec; p != NULL; p = p->next) {
3204 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3205 strcmp(p->name, last_name)>0){
3207 decode= encode= cap=0;
3209 if(p2 && strcmp(p->name, p2->name)==0){
3210 if(p->decode) decode=1;
3211 if(p->encode) encode=1;
3212 cap |= p->capabilities;
3217 last_name= p2->name;
3220 case CODEC_TYPE_VIDEO:
3223 case CODEC_TYPE_AUDIO:
3226 case CODEC_TYPE_SUBTITLE:
3235 decode ? "D": (/*p2->decoder ? "d":*/" "),
3238 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3239 cap & CODEC_CAP_DR1 ? "D":" ",
3240 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3242 /* if(p2->decoder && decode==0)
3243 printf(" use %s for decoding", p2->decoder->name);*/
3248 printf("Supported file protocols:\n");
3249 for(up = first_protocol; up != NULL; up = up->next)
3250 printf(" %s:", up->name);
3253 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3254 printf("Motion estimation methods:\n");
3258 if ((pp - motion_str + 1) == ME_ZERO)
3259 printf("(fastest)");
3260 else if ((pp - motion_str + 1) == ME_FULL)
3261 printf("(slowest)");
3262 else if ((pp - motion_str + 1) == ME_EPZS)
3263 printf("(default)");
3268 "Note, the names of encoders and decoders dont always match, so there are\n"
3269 "several cases where the above table shows encoder only or decoder only entries\n"
3270 "even though both encoding and decoding are supported for example, the h263\n"
3271 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3276 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3279 const char *p = str;
3286 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3293 static void opt_inter_matrix(const char *arg)
3295 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3296 parse_matrix_coeffs(inter_matrix, arg);
3299 static void opt_intra_matrix(const char *arg)
3301 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3302 parse_matrix_coeffs(intra_matrix, arg);
3305 static void opt_target(const char *arg)
3308 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3310 if(!strncmp(arg, "pal-", 4)) {
3313 } else if(!strncmp(arg, "ntsc-", 5)) {
3316 } else if(!strncmp(arg, "film-", 5)) {
3321 /* Calculate FR via float to avoid int overflow */
3322 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3325 } else if((fr == 29970) || (fr == 23976)) {
3328 /* Try to determine PAL/NTSC by peeking in the input files */
3329 if(nb_input_files) {
3331 for(j = 0; j < nb_input_files; j++) {
3332 for(i = 0; i < input_files[j]->nb_streams; i++) {
3333 AVCodecContext *c = input_files[j]->streams[i]->codec;
3334 if(c->codec_type != CODEC_TYPE_VIDEO)
3336 fr = c->time_base.den * 1000 / c->time_base.num;
3340 } else if((fr == 29970) || (fr == 23976)) {
3350 if(verbose && norm >= 0)
3351 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3355 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3356 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3357 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3361 if(!strcmp(arg, "vcd")) {
3363 opt_video_codec("mpeg1video");
3364 opt_audio_codec("mp2");
3367 opt_frame_size(norm ? "352x240" : "352x288");
3368 opt_frame_rate(frame_rates[norm]);
3369 opt_default("gop", norm ? "18" : "15");
3371 opt_default("b", "1150000");
3372 opt_default("maxrate", "1150000");
3373 opt_default("minrate", "1150000");
3374 opt_default("bufsize", "327680"); // 40*1024*8;
3376 opt_default("ab", "224000");
3377 audio_sample_rate = 44100;
3380 opt_default("packetsize", "2324");
3381 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3383 /* We have to offset the PTS, so that it is consistent with the SCR.
3384 SCR starts at 36000, but the first two packs contain only padding
3385 and the first pack from the other stream, respectively, may also have
3386 been written before.
3387 So the real data starts at SCR 36000+3*1200. */
3388 mux_preload= (36000+3*1200) / 90000.0; //0.44
3389 } else if(!strcmp(arg, "svcd")) {
3391 opt_video_codec("mpeg2video");
3392 opt_audio_codec("mp2");
3395 opt_frame_size(norm ? "480x480" : "480x576");
3396 opt_frame_rate(frame_rates[norm]);
3397 opt_default("gop", norm ? "18" : "15");
3399 opt_default("b", "2040000");
3400 opt_default("maxrate", "2516000");
3401 opt_default("minrate", "0"); //1145000;
3402 opt_default("bufsize", "1835008"); //224*1024*8;
3403 opt_default("flags", "+SCAN_OFFSET");
3406 opt_default("ab", "224000");
3407 audio_sample_rate = 44100;
3409 opt_default("packetsize", "2324");
3411 } else if(!strcmp(arg, "dvd")) {
3413 opt_video_codec("mpeg2video");
3414 opt_audio_codec("ac3");
3417 opt_frame_size(norm ? "720x480" : "720x576");
3418 opt_frame_rate(frame_rates[norm]);
3419 opt_default("gop", norm ? "18" : "15");
3421 opt_default("b", "6000000");
3422 opt_default("maxrate", "9000000");
3423 opt_default("minrate", "0"); //1500000;
3424 opt_default("bufsize", "1835008"); //224*1024*8;
3426 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3427 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3429 opt_default("ab", "448000");
3430 audio_sample_rate = 48000;
3432 } else if(!strncmp(arg, "dv", 2)) {
3436 opt_frame_size(norm ? "720x480" : "720x576");
3437 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3438 (norm ? "yuv411p" : "yuv420p"));
3439 opt_frame_rate(frame_rates[norm]);
3441 audio_sample_rate = 48000;
3445 fprintf(stderr, "Unknown target: %s\n", arg);
3450 static void opt_video_bsf(const char *arg)
3452 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3453 AVBitStreamFilterContext **bsfp;
3456 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3460 bsfp= &video_bitstream_filters;
3462 bsfp= &(*bsfp)->next;
3467 //FIXME avoid audio - video code duplication
3468 static void opt_audio_bsf(const char *arg)
3470 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3471 AVBitStreamFilterContext **bsfp;
3474 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3478 bsfp= &audio_bitstream_filters;
3480 bsfp= &(*bsfp)->next;
3485 static void show_version(void)
3487 /* TODO: add function interface to avutil and avformat */
3488 fprintf(stderr, "ffmpeg " FFMPEG_VERSION "\n"
3492 LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3496 static int opt_default(const char *opt, const char *arg){
3498 const AVOption *o= NULL;
3499 int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
3501 for(type=0; type<CODEC_TYPE_NB; type++){
3502 const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
3504 o = av_set_string(avctx_opts[type], opt, arg);
3507 o = av_set_string(avformat_opts, opt, arg);
3510 o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
3511 else if(opt[0] == 'v')
3512 o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
3513 else if(opt[0] == 's')
3514 o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
3519 // 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));
3521 //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3522 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3523 opt_names[opt_name_count++]= o->name;
3525 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3526 /* disable generate of real time pts in ffm (need to be supressed anyway) */
3527 if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)
3531 if(avctx_opts[0]->debug)
3532 av_log_level = AV_LOG_DEBUG;
3536 const OptionDef options[] = {
3538 { "L", 0, {(void*)show_license}, "show license" },
3539 { "h", 0, {(void*)show_help}, "show help" },
3540 { "version", 0, {(void*)show_version}, "show version" },
3541 { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3542 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3543 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3544 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3545 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3546 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3547 { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3548 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3549 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3550 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3551 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3552 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3553 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3554 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3555 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3556 { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3557 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3558 "add timings for benchmarking" },
3559 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3560 "dump each input packet" },
3561 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3562 "when dumping packets, also dump the payload" },
3563 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3564 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3565 { "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)", "" },
3566 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3567 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3568 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3569 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3570 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3571 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3572 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3573 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3574 { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3577 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3578 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3579 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3580 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3581 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3582 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3583 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3584 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3585 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3586 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3587 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3588 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3589 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3590 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3591 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3592 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3593 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3594 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3595 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3596 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
3597 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3598 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3599 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3600 { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3602 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
3603 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3604 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3605 "use same video quality as source (implies VBR)" },
3606 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3607 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3608 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3609 "deinterlace pictures" },
3610 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3611 { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
3612 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3613 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3614 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3615 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3616 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3617 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3618 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3619 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3622 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3623 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3624 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3625 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3626 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3627 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3628 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3629 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3630 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3631 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3633 /* subtitle options */
3634 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3635 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3636 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3639 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3640 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3641 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3644 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3645 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3647 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
3648 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
3650 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3654 static void show_banner(void)
3656 fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2007 Fabrice Bellard, et al.\n");
3657 fprintf(stderr, " configuration: " FFMPEG_CONFIGURATION "\n");
3658 fprintf(stderr, " libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
3659 fprintf(stderr, " libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
3660 fprintf(stderr, " libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
3661 fprintf(stderr, " built on " __DATE__ " " __TIME__);
3663 fprintf(stderr, ", gcc: " __VERSION__ "\n");
3665 fprintf(stderr, ", using a non-gcc compiler\n");
3669 static void show_license(void)
3674 "FFmpeg is free software; you can redistribute it and/or modify\n"
3675 "it under the terms of the GNU General Public License as published by\n"
3676 "the Free Software Foundation; either version 2 of the License, or\n"
3677 "(at your option) any later version.\n"
3679 "FFmpeg is distributed in the hope that it will be useful,\n"
3680 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3681 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
3682 "GNU General Public License for more details.\n"
3684 "You should have received a copy of the GNU General Public License\n"
3685 "along with FFmpeg; if not, write to the Free Software\n"
3686 "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
3690 "FFmpeg is free software; you can redistribute it and/or\n"
3691 "modify it under the terms of the GNU Lesser General Public\n"
3692 "License as published by the Free Software Foundation; either\n"
3693 "version 2.1 of the License, or (at your option) any later version.\n"
3695 "FFmpeg is distributed in the hope that it will be useful,\n"
3696 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3697 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
3698 "Lesser General Public License for more details.\n"
3700 "You should have received a copy of the GNU Lesser General Public\n"
3701 "License along with FFmpeg; if not, write to the Free Software\n"
3702 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
3708 static void show_help(void)
3711 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3712 "Hyper fast Audio and Video encoder\n");
3714 show_help_options(options, "Main options:\n",
3715 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3716 show_help_options(options, "\nVideo options:\n",
3717 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3719 show_help_options(options, "\nAdvanced Video options:\n",
3720 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3721 OPT_VIDEO | OPT_EXPERT);
3722 show_help_options(options, "\nAudio options:\n",
3723 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3725 show_help_options(options, "\nAdvanced Audio options:\n",
3726 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3727 OPT_AUDIO | OPT_EXPERT);
3728 show_help_options(options, "\nSubtitle options:\n",
3729 OPT_SUBTITLE | OPT_GRAB,
3731 show_help_options(options, "\nAudio/Video grab options:\n",
3734 show_help_options(options, "\nAdvanced options:\n",
3735 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3737 av_opt_show(avctx_opts[0], NULL);
3738 av_opt_show(avformat_opts, NULL);
3743 void parse_arg_file(const char *filename)
3745 opt_output_file(filename);
3748 int main(int argc, char **argv)
3755 for(i=0; i<CODEC_TYPE_NB; i++){
3756 avctx_opts[i]= avcodec_alloc_context2(i);
3758 avformat_opts = av_alloc_format_context();
3766 parse_options(argc, argv, options);
3768 /* file converter / grab */
3769 if (nb_output_files <= 0) {
3770 fprintf(stderr, "Must supply at least one output file\n");
3774 if (nb_input_files == 0) {
3775 fprintf(stderr, "Must supply at least one input file\n");
3780 av_encode(output_files, nb_output_files, input_files, nb_input_files,
3781 stream_maps, nb_stream_maps);
3782 ti = getutime() - ti;
3784 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3788 for(i=0;i<nb_output_files;i++) {
3789 /* maybe av_close_output_file ??? */
3790 AVFormatContext *s = output_files[i];
3792 if (!(s->oformat->flags & AVFMT_NOFILE))
3794 for(j=0;j<s->nb_streams;j++) {
3795 av_free(s->streams[j]->codec);
3796 av_free(s->streams[j]);
3800 for(i=0;i<nb_input_files;i++)
3801 av_close_input_file(input_files[i]);
3805 av_free(intra_matrix);
3806 av_free(inter_matrix);
3809 #ifdef CONFIG_POWERPC_PERF
3810 extern void powerpc_display_perf_report(void);
3811 powerpc_display_perf_report();
3812 #endif /* CONFIG_POWERPC_PERF */
3814 if (received_sigterm) {
3816 "Received signal %d: terminating.\n",
3817 (int) received_sigterm);
3821 exit(0); /* not all OS-es handle main() return value */